projects / wxWidgets.git / blob
? search:


12a9404d2ceeed22b7f971a4bc3981acd3775767
[wxWidgets.git] / wxPython / src / gtk / _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_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 float arg2 ;
4874 float arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 float val2 ;
4878 int ecode2 = 0 ;
4879 float val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_float(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4897 }
4898 arg2 = static_cast< float >(val2);
4899 ecode3 = SWIG_AsVal_float(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4902 }
4903 arg3 = static_cast< float >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->Scale(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "w",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->Set(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 int arg2 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 int val2 ;
4971 int ecode2 = 0 ;
4972 PyObject * obj0 = 0 ;
4973 PyObject * obj1 = 0 ;
4974 char * kwnames[] = {
4975 (char *) "self",(char *) "w", NULL
4976 };
4977
4978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 ecode2 = SWIG_AsVal_int(obj1, &val2);
4985 if (!SWIG_IsOK(ecode2)) {
4986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4987 }
4988 arg2 = static_cast< int >(val2);
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 (arg1)->SetWidth(arg2);
4992 wxPyEndAllowThreads(__tstate);
4993 if (PyErr_Occurred()) SWIG_fail;
4994 }
4995 resultobj = SWIG_Py_Void();
4996 return resultobj;
4997 fail:
4998 return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5003 PyObject *resultobj = 0;
5004 wxSize *arg1 = (wxSize *) 0 ;
5005 int arg2 ;
5006 void *argp1 = 0 ;
5007 int res1 = 0 ;
5008 int val2 ;
5009 int ecode2 = 0 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "self",(char *) "h", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5018 if (!SWIG_IsOK(res1)) {
5019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5020 }
5021 arg1 = reinterpret_cast< wxSize * >(argp1);
5022 ecode2 = SWIG_AsVal_int(obj1, &val2);
5023 if (!SWIG_IsOK(ecode2)) {
5024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5025 }
5026 arg2 = static_cast< int >(val2);
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 (arg1)->SetHeight(arg2);
5030 wxPyEndAllowThreads(__tstate);
5031 if (PyErr_Occurred()) SWIG_fail;
5032 }
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035 fail:
5036 return NULL;
5037 }
5038
5039
5040 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5041 PyObject *resultobj = 0;
5042 wxSize *arg1 = (wxSize *) 0 ;
5043 int result;
5044 void *argp1 = 0 ;
5045 int res1 = 0 ;
5046 PyObject *swig_obj[1] ;
5047
5048 if (!args) SWIG_fail;
5049 swig_obj[0] = args;
5050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5051 if (!SWIG_IsOK(res1)) {
5052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5053 }
5054 arg1 = reinterpret_cast< wxSize * >(argp1);
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = (int)((wxSize const *)arg1)->GetWidth();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_From_int(static_cast< int >(result));
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 wxSize *arg1 = (wxSize *) 0 ;
5071 int result;
5072 void *argp1 = 0 ;
5073 int res1 = 0 ;
5074 PyObject *swig_obj[1] ;
5075
5076 if (!args) SWIG_fail;
5077 swig_obj[0] = args;
5078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5079 if (!SWIG_IsOK(res1)) {
5080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5081 }
5082 arg1 = reinterpret_cast< wxSize * >(argp1);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = (int)((wxSize const *)arg1)->GetHeight();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_From_int(static_cast< int >(result));
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 bool result;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 PyObject *swig_obj[1] ;
5103
5104 if (!args) SWIG_fail;
5105 swig_obj[0] = args;
5106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5119 }
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 wxSize *arg2 = 0 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 wxSize temp2 ;
5133 PyObject * obj0 = 0 ;
5134 PyObject * obj1 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "self",(char *) "size", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5143 }
5144 arg1 = reinterpret_cast< wxSize * >(argp1);
5145 {
5146 arg2 = &temp2;
5147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5148 }
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 (arg1)->SetDefaults((wxSize const &)*arg2);
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 PyObject *result = 0 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (PyObject *)wxSize_Get(arg1);
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = result;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *obj;
5192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5193 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5194 return SWIG_Py_Void();
5195 }
5196
5197 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5198 return SWIG_Python_InitShadowInstance(args);
5199 }
5200
5201 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5202 PyObject *resultobj = 0;
5203 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5204 double arg2 ;
5205 void *argp1 = 0 ;
5206 int res1 = 0 ;
5207 double val2 ;
5208 int ecode2 = 0 ;
5209 PyObject *swig_obj[2] ;
5210
5211 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5213 if (!SWIG_IsOK(res1)) {
5214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5215 }
5216 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5218 if (!SWIG_IsOK(ecode2)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5220 }
5221 arg2 = static_cast< double >(val2);
5222 if (arg1) (arg1)->x = arg2;
5223
5224 resultobj = SWIG_Py_Void();
5225 return resultobj;
5226 fail:
5227 return NULL;
5228 }
5229
5230
5231 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5232 PyObject *resultobj = 0;
5233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5234 double result;
5235 void *argp1 = 0 ;
5236 int res1 = 0 ;
5237 PyObject *swig_obj[1] ;
5238
5239 if (!args) SWIG_fail;
5240 swig_obj[0] = args;
5241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5242 if (!SWIG_IsOK(res1)) {
5243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5244 }
5245 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5246 result = (double) ((arg1)->x);
5247 resultobj = SWIG_From_double(static_cast< double >(result));
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5255 PyObject *resultobj = 0;
5256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5257 double arg2 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 double val2 ;
5261 int ecode2 = 0 ;
5262 PyObject *swig_obj[2] ;
5263
5264 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5268 }
5269 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5271 if (!SWIG_IsOK(ecode2)) {
5272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5273 }
5274 arg2 = static_cast< double >(val2);
5275 if (arg1) (arg1)->y = arg2;
5276
5277 resultobj = SWIG_Py_Void();
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5287 double result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject *swig_obj[1] ;
5291
5292 if (!args) SWIG_fail;
5293 swig_obj[0] = args;
5294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5295 if (!SWIG_IsOK(res1)) {
5296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5297 }
5298 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5299 result = (double) ((arg1)->y);
5300 resultobj = SWIG_From_double(static_cast< double >(result));
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 double arg1 = (double) 0.0 ;
5310 double arg2 = (double) 0.0 ;
5311 wxRealPoint *result = 0 ;
5312 double val1 ;
5313 int ecode1 = 0 ;
5314 double val2 ;
5315 int ecode2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "x",(char *) "y", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5323 if (obj0) {
5324 ecode1 = SWIG_AsVal_double(obj0, &val1);
5325 if (!SWIG_IsOK(ecode1)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5327 }
5328 arg1 = static_cast< double >(val1);
5329 }
5330 if (obj1) {
5331 ecode2 = SWIG_AsVal_double(obj1, &val2);
5332 if (!SWIG_IsOK(ecode2)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5334 }
5335 arg2 = static_cast< double >(val2);
5336 }
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 PyObject *swig_obj[1] ;
5356
5357 if (!args) SWIG_fail;
5358 swig_obj[0] = args;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 delete arg1;
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 PyObject *arg2 = (PyObject *) 0 ;
5382 bool result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject * obj0 = 0 ;
5386 PyObject * obj1 = 0 ;
5387 char * kwnames[] = {
5388 (char *) "self",(char *) "other", NULL
5389 };
5390
5391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5393 if (!SWIG_IsOK(res1)) {
5394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5395 }
5396 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5397 arg2 = obj1;
5398 {
5399 result = (bool)wxRealPoint___eq__(arg1,arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5404 }
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5412 PyObject *resultobj = 0;
5413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5414 PyObject *arg2 = (PyObject *) 0 ;
5415 bool result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject * obj0 = 0 ;
5419 PyObject * obj1 = 0 ;
5420 char * kwnames[] = {
5421 (char *) "self",(char *) "other", NULL
5422 };
5423
5424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5426 if (!SWIG_IsOK(res1)) {
5427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5428 }
5429 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5430 arg2 = obj1;
5431 {
5432 result = (bool)wxRealPoint___ne__(arg1,arg2);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 wxRealPoint *arg2 = 0 ;
5448 wxRealPoint result;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 wxRealPoint temp2 ;
5452 PyObject * obj0 = 0 ;
5453 PyObject * obj1 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "pt", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 {
5465 arg2 = &temp2;
5466 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 wxRealPoint *arg2 = 0 ;
5485 wxRealPoint result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 wxRealPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char * kwnames[] = {
5492 (char *) "self",(char *) "pt", NULL
5493 };
5494
5495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5497 if (!SWIG_IsOK(res1)) {
5498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5499 }
5500 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5501 {
5502 arg2 = &temp2;
5503 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5504 }
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5521 double arg2 ;
5522 double arg3 ;
5523 void *argp1 = 0 ;
5524 int res1 = 0 ;
5525 double val2 ;
5526 int ecode2 = 0 ;
5527 double val3 ;
5528 int ecode3 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 char * kwnames[] = {
5533 (char *) "self",(char *) "x",(char *) "y", NULL
5534 };
5535
5536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_double(obj1, &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5545 }
5546 arg2 = static_cast< double >(val2);
5547 ecode3 = SWIG_AsVal_double(obj2, &val3);
5548 if (!SWIG_IsOK(ecode3)) {
5549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5550 }
5551 arg3 = static_cast< double >(val3);
5552 {
5553 PyThreadState* __tstate = wxPyBeginAllowThreads();
5554 wxRealPoint_Set(arg1,arg2,arg3);
5555 wxPyEndAllowThreads(__tstate);
5556 if (PyErr_Occurred()) SWIG_fail;
5557 }
5558 resultobj = SWIG_Py_Void();
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 PyObject *resultobj = 0;
5567 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5568 PyObject *result = 0 ;
5569 void *argp1 = 0 ;
5570 int res1 = 0 ;
5571 PyObject *swig_obj[1] ;
5572
5573 if (!args) SWIG_fail;
5574 swig_obj[0] = args;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5580 {
5581 PyThreadState* __tstate = wxPyBeginAllowThreads();
5582 result = (PyObject *)wxRealPoint_Get(arg1);
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = result;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *obj;
5595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5596 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5597 return SWIG_Py_Void();
5598 }
5599
5600 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 return SWIG_Python_InitShadowInstance(args);
5602 }
5603
5604 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5605 PyObject *resultobj = 0;
5606 wxPoint *arg1 = (wxPoint *) 0 ;
5607 int arg2 ;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 int val2 ;
5611 int ecode2 = 0 ;
5612 PyObject *swig_obj[2] ;
5613
5614 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5623 }
5624 arg2 = static_cast< int >(val2);
5625 if (arg1) (arg1)->x = arg2;
5626
5627 resultobj = SWIG_Py_Void();
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxPoint *arg1 = (wxPoint *) 0 ;
5637 int result;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5647 }
5648 arg1 = reinterpret_cast< wxPoint * >(argp1);
5649 result = (int) ((arg1)->x);
5650 resultobj = SWIG_From_int(static_cast< int >(result));
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5658 PyObject *resultobj = 0;
5659 wxPoint *arg1 = (wxPoint *) 0 ;
5660 int arg2 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 int val2 ;
5664 int ecode2 = 0 ;
5665 PyObject *swig_obj[2] ;
5666
5667 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxPoint * >(argp1);
5673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5674 if (!SWIG_IsOK(ecode2)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5676 }
5677 arg2 = static_cast< int >(val2);
5678 if (arg1) (arg1)->y = arg2;
5679
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxPoint *arg1 = (wxPoint *) 0 ;
5690 int result;
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_wxPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxPoint * >(argp1);
5702 result = (int) ((arg1)->y);
5703 resultobj = SWIG_From_int(static_cast< int >(result));
5704 return resultobj;
5705 fail:
5706 return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711 PyObject *resultobj = 0;
5712 int arg1 = (int) 0 ;
5713 int arg2 = (int) 0 ;
5714 wxPoint *result = 0 ;
5715 int val1 ;
5716 int ecode1 = 0 ;
5717 int val2 ;
5718 int ecode2 = 0 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 char * kwnames[] = {
5722 (char *) "x",(char *) "y", NULL
5723 };
5724
5725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5726 if (obj0) {
5727 ecode1 = SWIG_AsVal_int(obj0, &val1);
5728 if (!SWIG_IsOK(ecode1)) {
5729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5730 }
5731 arg1 = static_cast< int >(val1);
5732 }
5733 if (obj1) {
5734 ecode2 = SWIG_AsVal_int(obj1, &val2);
5735 if (!SWIG_IsOK(ecode2)) {
5736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5737 }
5738 arg2 = static_cast< int >(val2);
5739 }
5740 {
5741 PyThreadState* __tstate = wxPyBeginAllowThreads();
5742 result = (wxPoint *)new wxPoint(arg1,arg2);
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 PyObject *swig_obj[1] ;
5759
5760 if (!args) SWIG_fail;
5761 swig_obj[0] = args;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 delete arg1;
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 PyObject *arg2 = (PyObject *) 0 ;
5785 bool result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 char * kwnames[] = {
5791 (char *) "self",(char *) "other", NULL
5792 };
5793
5794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5796 if (!SWIG_IsOK(res1)) {
5797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5798 }
5799 arg1 = reinterpret_cast< wxPoint * >(argp1);
5800 arg2 = obj1;
5801 {
5802 result = (bool)wxPoint___eq__(arg1,arg2);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 {
5806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5807 }
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 PyObject *arg2 = (PyObject *) 0 ;
5818 bool result;
5819 void *argp1 = 0 ;
5820 int res1 = 0 ;
5821 PyObject * obj0 = 0 ;
5822 PyObject * obj1 = 0 ;
5823 char * kwnames[] = {
5824 (char *) "self",(char *) "other", NULL
5825 };
5826
5827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5829 if (!SWIG_IsOK(res1)) {
5830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5831 }
5832 arg1 = reinterpret_cast< wxPoint * >(argp1);
5833 arg2 = obj1;
5834 {
5835 result = (bool)wxPoint___ne__(arg1,arg2);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 {
5839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5840 }
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 wxPoint *arg2 = 0 ;
5851 wxPoint result;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 wxPoint temp2 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "self",(char *) "pt", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 {
5868 arg2 = &temp2;
5869 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5870 }
5871 {
5872 PyThreadState* __tstate = wxPyBeginAllowThreads();
5873 result = (arg1)->operator +((wxPoint const &)*arg2);
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = 0;
5886 wxPoint *arg1 = (wxPoint *) 0 ;
5887 wxPoint *arg2 = 0 ;
5888 wxPoint result;
5889 void *argp1 = 0 ;
5890 int res1 = 0 ;
5891 wxPoint temp2 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 char * kwnames[] = {
5895 (char *) "self",(char *) "pt", NULL
5896 };
5897
5898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5900 if (!SWIG_IsOK(res1)) {
5901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5902 }
5903 arg1 = reinterpret_cast< wxPoint * >(argp1);
5904 {
5905 arg2 = &temp2;
5906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = (arg1)->operator -((wxPoint const &)*arg2);
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj = 0;
5923 wxPoint *arg1 = (wxPoint *) 0 ;
5924 wxPoint *arg2 = 0 ;
5925 wxPoint *result = 0 ;
5926 void *argp1 = 0 ;
5927 int res1 = 0 ;
5928 wxPoint temp2 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "self",(char *) "pt", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5937 if (!SWIG_IsOK(res1)) {
5938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5939 }
5940 arg1 = reinterpret_cast< wxPoint * >(argp1);
5941 {
5942 arg2 = &temp2;
5943 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5944 }
5945 {
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 {
5948 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5949 result = (wxPoint *) &_result_ref;
5950 }
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 wxPoint *arg2 = 0 ;
5965 wxPoint *result = 0 ;
5966 void *argp1 = 0 ;
5967 int res1 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5977 if (!SWIG_IsOK(res1)) {
5978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5979 }
5980 arg1 = reinterpret_cast< wxPoint * >(argp1);
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5989 result = (wxPoint *) &_result_ref;
5990 }
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 long arg2 ;
6005 long arg3 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 long val2 ;
6009 int ecode2 = 0 ;
6010 long val3 ;
6011 int ecode3 = 0 ;
6012 PyObject * obj0 = 0 ;
6013 PyObject * obj1 = 0 ;
6014 PyObject * obj2 = 0 ;
6015 char * kwnames[] = {
6016 (char *) "self",(char *) "x",(char *) "y", NULL
6017 };
6018
6019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6021 if (!SWIG_IsOK(res1)) {
6022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6023 }
6024 arg1 = reinterpret_cast< wxPoint * >(argp1);
6025 ecode2 = SWIG_AsVal_long(obj1, &val2);
6026 if (!SWIG_IsOK(ecode2)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6028 }
6029 arg2 = static_cast< long >(val2);
6030 ecode3 = SWIG_AsVal_long(obj2, &val3);
6031 if (!SWIG_IsOK(ecode3)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6033 }
6034 arg3 = static_cast< long >(val3);
6035 {
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxPoint_Set(arg1,arg2,arg3);
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 resultobj = SWIG_Py_Void();
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 PyObject *resultobj = 0;
6050 wxPoint *arg1 = (wxPoint *) 0 ;
6051 PyObject *result = 0 ;
6052 void *argp1 = 0 ;
6053 int res1 = 0 ;
6054 PyObject *swig_obj[1] ;
6055
6056 if (!args) SWIG_fail;
6057 swig_obj[0] = args;
6058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6059 if (!SWIG_IsOK(res1)) {
6060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6061 }
6062 arg1 = reinterpret_cast< wxPoint * >(argp1);
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (PyObject *)wxPoint_Get(arg1);
6066 wxPyEndAllowThreads(__tstate);
6067 if (PyErr_Occurred()) SWIG_fail;
6068 }
6069 resultobj = result;
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6077 PyObject *obj;
6078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6079 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6080 return SWIG_Py_Void();
6081 }
6082
6083 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084 return SWIG_Python_InitShadowInstance(args);
6085 }
6086
6087 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 int arg1 = (int) 0 ;
6090 int arg2 = (int) 0 ;
6091 int arg3 = (int) 0 ;
6092 int arg4 = (int) 0 ;
6093 wxRect *result = 0 ;
6094 int val1 ;
6095 int ecode1 = 0 ;
6096 int val2 ;
6097 int ecode2 = 0 ;
6098 int val3 ;
6099 int ecode3 = 0 ;
6100 int val4 ;
6101 int ecode4 = 0 ;
6102 PyObject * obj0 = 0 ;
6103 PyObject * obj1 = 0 ;
6104 PyObject * obj2 = 0 ;
6105 PyObject * obj3 = 0 ;
6106 char * kwnames[] = {
6107 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6108 };
6109
6110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6111 if (obj0) {
6112 ecode1 = SWIG_AsVal_int(obj0, &val1);
6113 if (!SWIG_IsOK(ecode1)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6115 }
6116 arg1 = static_cast< int >(val1);
6117 }
6118 if (obj1) {
6119 ecode2 = SWIG_AsVal_int(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6122 }
6123 arg2 = static_cast< int >(val2);
6124 }
6125 if (obj2) {
6126 ecode3 = SWIG_AsVal_int(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6129 }
6130 arg3 = static_cast< int >(val3);
6131 }
6132 if (obj3) {
6133 ecode4 = SWIG_AsVal_int(obj3, &val4);
6134 if (!SWIG_IsOK(ecode4)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6136 }
6137 arg4 = static_cast< int >(val4);
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxPoint *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxPoint temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "topLeft",(char *) "bottomRight", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxPoint *arg1 = 0 ;
6190 wxSize *arg2 = 0 ;
6191 wxRect *result = 0 ;
6192 wxPoint temp1 ;
6193 wxSize temp2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "pos",(char *) "size", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6201 {
6202 arg1 = &temp1;
6203 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6204 }
6205 {
6206 arg2 = &temp2;
6207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6208 }
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxSize *arg1 = 0 ;
6225 wxRect *result = 0 ;
6226 wxSize temp1 ;
6227 PyObject * obj0 = 0 ;
6228 char * kwnames[] = {
6229 (char *) "size", NULL
6230 };
6231
6232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6233 {
6234 arg1 = &temp1;
6235 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6240 wxPyEndAllowThreads(__tstate);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251 PyObject *resultobj = 0;
6252 wxRect *arg1 = (wxRect *) 0 ;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 delete arg1;
6267
6268 wxPyEndAllowThreads(__tstate);
6269 if (PyErr_Occurred()) SWIG_fail;
6270 }
6271 resultobj = SWIG_Py_Void();
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6279 PyObject *resultobj = 0;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int result;
6282 void *argp1 = 0 ;
6283 int res1 = 0 ;
6284 PyObject *swig_obj[1] ;
6285
6286 if (!args) SWIG_fail;
6287 swig_obj[0] = args;
6288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6289 if (!SWIG_IsOK(res1)) {
6290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6291 }
6292 arg1 = reinterpret_cast< wxRect * >(argp1);
6293 {
6294 PyThreadState* __tstate = wxPyBeginAllowThreads();
6295 result = (int)((wxRect const *)arg1)->GetX();
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 resultobj = SWIG_From_int(static_cast< int >(result));
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj = 0;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 ;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 char * kwnames[] = {
6317 (char *) "self",(char *) "x", NULL
6318 };
6319
6320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6322 if (!SWIG_IsOK(res1)) {
6323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6324 }
6325 arg1 = reinterpret_cast< wxRect * >(argp1);
6326 ecode2 = SWIG_AsVal_int(obj1, &val2);
6327 if (!SWIG_IsOK(ecode2)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6329 }
6330 arg2 = static_cast< int >(val2);
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 (arg1)->SetX(arg2);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_Py_Void();
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 int result;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 result = (int)(arg1)->GetY();
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_From_int(static_cast< int >(result));
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 int val2 ;
6379 int ecode2 = 0 ;
6380 PyObject * obj0 = 0 ;
6381 PyObject * obj1 = 0 ;
6382 char * kwnames[] = {
6383 (char *) "self",(char *) "y", NULL
6384 };
6385
6386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6388 if (!SWIG_IsOK(res1)) {
6389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6390 }
6391 arg1 = reinterpret_cast< wxRect * >(argp1);
6392 ecode2 = SWIG_AsVal_int(obj1, &val2);
6393 if (!SWIG_IsOK(ecode2)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6395 }
6396 arg2 = static_cast< int >(val2);
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->SetY(arg2);
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_Py_Void();
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6411 PyObject *resultobj = 0;
6412 wxRect *arg1 = (wxRect *) 0 ;
6413 int result;
6414 void *argp1 = 0 ;
6415 int res1 = 0 ;
6416 PyObject *swig_obj[1] ;
6417
6418 if (!args) SWIG_fail;
6419 swig_obj[0] = args;
6420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6421 if (!SWIG_IsOK(res1)) {
6422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6423 }
6424 arg1 = reinterpret_cast< wxRect * >(argp1);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 result = (int)((wxRect const *)arg1)->GetWidth();
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_From_int(static_cast< int >(result));
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int arg2 ;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 int val2 ;
6445 int ecode2 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 PyObject * obj1 = 0 ;
6448 char * kwnames[] = {
6449 (char *) "self",(char *) "w", NULL
6450 };
6451
6452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6454 if (!SWIG_IsOK(res1)) {
6455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6456 }
6457 arg1 = reinterpret_cast< wxRect * >(argp1);
6458 ecode2 = SWIG_AsVal_int(obj1, &val2);
6459 if (!SWIG_IsOK(ecode2)) {
6460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6461 }
6462 arg2 = static_cast< int >(val2);
6463 {
6464 PyThreadState* __tstate = wxPyBeginAllowThreads();
6465 (arg1)->SetWidth(arg2);
6466 wxPyEndAllowThreads(__tstate);
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_Py_Void();
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int result;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 PyObject *swig_obj[1] ;
6483
6484 if (!args) SWIG_fail;
6485 swig_obj[0] = args;
6486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6487 if (!SWIG_IsOK(res1)) {
6488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6489 }
6490 arg1 = reinterpret_cast< wxRect * >(argp1);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 result = (int)((wxRect const *)arg1)->GetHeight();
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_From_int(static_cast< int >(result));
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int arg2 ;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 int val2 ;
6511 int ecode2 = 0 ;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char * kwnames[] = {
6515 (char *) "self",(char *) "h", NULL
6516 };
6517
6518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6520 if (!SWIG_IsOK(res1)) {
6521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6522 }
6523 arg1 = reinterpret_cast< wxRect * >(argp1);
6524 ecode2 = SWIG_AsVal_int(obj1, &val2);
6525 if (!SWIG_IsOK(ecode2)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6527 }
6528 arg2 = static_cast< int >(val2);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 (arg1)->SetHeight(arg2);
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_Py_Void();
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint result;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 PyObject *swig_obj[1] ;
6549
6550 if (!args) SWIG_fail;
6551 swig_obj[0] = args;
6552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6553 if (!SWIG_IsOK(res1)) {
6554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6555 }
6556 arg1 = reinterpret_cast< wxRect * >(argp1);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 result = ((wxRect const *)arg1)->GetPosition();
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 wxPoint *arg2 = 0 ;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 wxPoint temp2 ;
6577 PyObject * obj0 = 0 ;
6578 PyObject * obj1 = 0 ;
6579 char * kwnames[] = {
6580 (char *) "self",(char *) "p", NULL
6581 };
6582
6583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 arg2 = &temp2;
6591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6592 }
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 (arg1)->SetPosition((wxPoint const &)*arg2);
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_Py_Void();
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxSize result;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 PyObject *swig_obj[1] ;
6613
6614 if (!args) SWIG_fail;
6615 swig_obj[0] = args;
6616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6617 if (!SWIG_IsOK(res1)) {
6618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6619 }
6620 arg1 = reinterpret_cast< wxRect * >(argp1);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = ((wxRect const *)arg1)->GetSize();
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 wxSize *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 wxSize temp2 ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "s", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 arg2 = &temp2;
6655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetSize((wxSize const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 bool result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)((wxRect const *)arg1)->IsEmpty();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxPoint result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetTopLeft();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxPoint *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxPoint temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "p", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = ((wxRect const *)arg1)->GetBottomRight();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxPoint *arg2 = 0 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 wxPoint temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char * kwnames[] = {
6802 (char *) "self",(char *) "p", NULL
6803 };
6804
6805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 arg2 = &temp2;
6813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6814 }
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6818 wxPyEndAllowThreads(__tstate);
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_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 int 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_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 PyThreadState* __tstate = wxPyBeginAllowThreads();
6845 result = (int)((wxRect const *)arg1)->GetLeft();
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 resultobj = SWIG_From_int(static_cast< int >(result));
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6857 PyObject *resultobj = 0;
6858 wxRect *arg1 = (wxRect *) 0 ;
6859 int result;
6860 void *argp1 = 0 ;
6861 int res1 = 0 ;
6862 PyObject *swig_obj[1] ;
6863
6864 if (!args) SWIG_fail;
6865 swig_obj[0] = args;
6866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6869 }
6870 arg1 = reinterpret_cast< wxRect * >(argp1);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 result = (int)((wxRect const *)arg1)->GetTop();
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_From_int(static_cast< int >(result));
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 int result;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6897 }
6898 arg1 = reinterpret_cast< wxRect * >(argp1);
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (int)((wxRect const *)arg1)->GetBottom();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_From_int(static_cast< int >(result));
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxRect *arg1 = (wxRect *) 0 ;
6915 int result;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6925 }
6926 arg1 = reinterpret_cast< wxRect * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (int)((wxRect const *)arg1)->GetRight();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_From_int(static_cast< int >(result));
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 int arg2 ;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 int val2 ;
6947 int ecode2 = 0 ;
6948 PyObject * obj0 = 0 ;
6949 PyObject * obj1 = 0 ;
6950 char * kwnames[] = {
6951 (char *) "self",(char *) "left", NULL
6952 };
6953
6954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6956 if (!SWIG_IsOK(res1)) {
6957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6958 }
6959 arg1 = reinterpret_cast< wxRect * >(argp1);
6960 ecode2 = SWIG_AsVal_int(obj1, &val2);
6961 if (!SWIG_IsOK(ecode2)) {
6962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6963 }
6964 arg2 = static_cast< int >(val2);
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 (arg1)->SetLeft(arg2);
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 int arg2 ;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 int val2 ;
6985 int ecode2 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 char * kwnames[] = {
6989 (char *) "self",(char *) "right", NULL
6990 };
6991
6992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6996 }
6997 arg1 = reinterpret_cast< wxRect * >(argp1);
6998 ecode2 = SWIG_AsVal_int(obj1, &val2);
6999 if (!SWIG_IsOK(ecode2)) {
7000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7001 }
7002 arg2 = static_cast< int >(val2);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 (arg1)->SetRight(arg2);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 int arg2 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "top", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 (arg1)->SetTop(arg2);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_Py_Void();
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj = 0;
7056 wxRect *arg1 = (wxRect *) 0 ;
7057 int arg2 ;
7058 void *argp1 = 0 ;
7059 int res1 = 0 ;
7060 int val2 ;
7061 int ecode2 = 0 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "bottom", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 ecode2 = SWIG_AsVal_int(obj1, &val2);
7075 if (!SWIG_IsOK(ecode2)) {
7076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7077 }
7078 arg2 = static_cast< int >(val2);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 (arg1)->SetBottom(arg2);
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_Py_Void();
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int arg2 ;
7096 int arg3 ;
7097 wxRect *result = 0 ;
7098 void *argp1 = 0 ;
7099 int res1 = 0 ;
7100 int val2 ;
7101 int ecode2 = 0 ;
7102 int val3 ;
7103 int ecode3 = 0 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 PyObject * obj2 = 0 ;
7107 char * kwnames[] = {
7108 (char *) "self",(char *) "dx",(char *) "dy", NULL
7109 };
7110
7111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 ecode2 = SWIG_AsVal_int(obj1, &val2);
7118 if (!SWIG_IsOK(ecode2)) {
7119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7120 }
7121 arg2 = static_cast< int >(val2);
7122 ecode3 = SWIG_AsVal_int(obj2, &val3);
7123 if (!SWIG_IsOK(ecode3)) {
7124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7125 }
7126 arg3 = static_cast< int >(val3);
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 {
7130 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7131 result = (wxRect *) &_result_ref;
7132 }
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 int arg2 ;
7147 int arg3 ;
7148 wxRect *result = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 int val2 ;
7152 int ecode2 = 0 ;
7153 int val3 ;
7154 int ecode3 = 0 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 PyObject * obj2 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "dx",(char *) "dy", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) 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_Deflate" "', 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_Deflate" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 ecode3 = SWIG_AsVal_int(obj2, &val3);
7174 if (!SWIG_IsOK(ecode3)) {
7175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7176 }
7177 arg3 = static_cast< int >(val3);
7178 {
7179 PyThreadState* __tstate = wxPyBeginAllowThreads();
7180 {
7181 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7182 result = (wxRect *) &_result_ref;
7183 }
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7188 return resultobj;
7189 fail:
7190 return NULL;
7191 }
7192
7193
7194 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7195 PyObject *resultobj = 0;
7196 wxRect *arg1 = (wxRect *) 0 ;
7197 int arg2 ;
7198 int arg3 ;
7199 void *argp1 = 0 ;
7200 int res1 = 0 ;
7201 int val2 ;
7202 int ecode2 = 0 ;
7203 int val3 ;
7204 int ecode3 = 0 ;
7205 PyObject * obj0 = 0 ;
7206 PyObject * obj1 = 0 ;
7207 PyObject * obj2 = 0 ;
7208 char * kwnames[] = {
7209 (char *) "self",(char *) "dx",(char *) "dy", NULL
7210 };
7211
7212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7214 if (!SWIG_IsOK(res1)) {
7215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7216 }
7217 arg1 = reinterpret_cast< wxRect * >(argp1);
7218 ecode2 = SWIG_AsVal_int(obj1, &val2);
7219 if (!SWIG_IsOK(ecode2)) {
7220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7221 }
7222 arg2 = static_cast< int >(val2);
7223 ecode3 = SWIG_AsVal_int(obj2, &val3);
7224 if (!SWIG_IsOK(ecode3)) {
7225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7226 }
7227 arg3 = static_cast< int >(val3);
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 (arg1)->Offset(arg2,arg3);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 resultobj = SWIG_Py_Void();
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7242 PyObject *resultobj = 0;
7243 wxRect *arg1 = (wxRect *) 0 ;
7244 wxPoint *arg2 = 0 ;
7245 void *argp1 = 0 ;
7246 int res1 = 0 ;
7247 wxPoint temp2 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "pt", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 {
7261 arg2 = &temp2;
7262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7263 }
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->Offset((wxPoint const &)*arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 wxRect *arg2 = 0 ;
7281 wxRect result;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 wxRect temp2 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "rect", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 {
7298 arg2 = &temp2;
7299 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7300 }
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 result = (arg1)->Intersect((wxRect const &)*arg2);
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = 0;
7316 wxRect *arg1 = (wxRect *) 0 ;
7317 wxRect *arg2 = 0 ;
7318 wxRect result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 wxRect temp2 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char * kwnames[] = {
7325 (char *) "self",(char *) "rect", NULL
7326 };
7327
7328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7332 }
7333 arg1 = reinterpret_cast< wxRect * >(argp1);
7334 {
7335 arg2 = &temp2;
7336 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7337 }
7338 {
7339 PyThreadState* __tstate = wxPyBeginAllowThreads();
7340 result = (arg1)->Union((wxRect const &)*arg2);
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 wxRect *arg2 = 0 ;
7355 wxRect result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 wxRect temp2 ;
7359 PyObject * obj0 = 0 ;
7360 PyObject * obj1 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "rect", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 {
7372 arg2 = &temp2;
7373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7374 }
7375 {
7376 PyThreadState* __tstate = wxPyBeginAllowThreads();
7377 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj = 0;
7390 wxRect *arg1 = (wxRect *) 0 ;
7391 wxRect *arg2 = 0 ;
7392 wxRect *result = 0 ;
7393 void *argp1 = 0 ;
7394 int res1 = 0 ;
7395 wxRect temp2 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "rect", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 {
7409 arg2 = &temp2;
7410 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 {
7415 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7416 result = (wxRect *) &_result_ref;
7417 }
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj = 0;
7430 wxRect *arg1 = (wxRect *) 0 ;
7431 PyObject *arg2 = (PyObject *) 0 ;
7432 bool result;
7433 void *argp1 = 0 ;
7434 int res1 = 0 ;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "other", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 arg2 = obj1;
7448 {
7449 result = (bool)wxRect___eq__(arg1,arg2);
7450 if (PyErr_Occurred()) SWIG_fail;
7451 }
7452 {
7453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7454 }
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj = 0;
7463 wxRect *arg1 = (wxRect *) 0 ;
7464 PyObject *arg2 = (PyObject *) 0 ;
7465 bool result;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 PyObject * obj0 = 0 ;
7469 PyObject * obj1 = 0 ;
7470 char * kwnames[] = {
7471 (char *) "self",(char *) "other", NULL
7472 };
7473
7474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7476 if (!SWIG_IsOK(res1)) {
7477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7478 }
7479 arg1 = reinterpret_cast< wxRect * >(argp1);
7480 arg2 = obj1;
7481 {
7482 result = (bool)wxRect___ne__(arg1,arg2);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxRect *arg1 = (wxRect *) 0 ;
7497 int arg2 ;
7498 int arg3 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 int val3 ;
7505 int ecode3 = 0 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 PyObject * obj2 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "x",(char *) "y", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 ecode2 = SWIG_AsVal_int(obj1, &val2);
7520 if (!SWIG_IsOK(ecode2)) {
7521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7522 }
7523 arg2 = static_cast< int >(val2);
7524 ecode3 = SWIG_AsVal_int(obj2, &val3);
7525 if (!SWIG_IsOK(ecode3)) {
7526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7527 }
7528 arg3 = static_cast< int >(val3);
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxPoint *arg2 = 0 ;
7548 bool result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 wxPoint temp2 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char * kwnames[] = {
7555 (char *) "self",(char *) "pt", NULL
7556 };
7557
7558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7560 if (!SWIG_IsOK(res1)) {
7561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7562 }
7563 arg1 = reinterpret_cast< wxRect * >(argp1);
7564 {
7565 arg2 = &temp2;
7566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxRect *arg1 = (wxRect *) 0 ;
7586 wxRect *arg2 = 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 wxRect temp2 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "rect", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7601 }
7602 arg1 = reinterpret_cast< wxRect * >(argp1);
7603 {
7604 arg2 = &temp2;
7605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 wxRect *arg2 = 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 wxRect temp2 ;
7630 PyObject * obj0 = 0 ;
7631 PyObject * obj1 = 0 ;
7632 char * kwnames[] = {
7633 (char *) "self",(char *) "rect", NULL
7634 };
7635
7636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7638 if (!SWIG_IsOK(res1)) {
7639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7640 }
7641 arg1 = reinterpret_cast< wxRect * >(argp1);
7642 {
7643 arg2 = &temp2;
7644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7645 }
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 {
7653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7654 }
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxRect *arg1 = (wxRect *) 0 ;
7664 wxRect *arg2 = 0 ;
7665 int arg3 = (int) wxBOTH ;
7666 wxRect result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 wxRect temp2 ;
7670 int val3 ;
7671 int ecode3 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 PyObject * obj2 = 0 ;
7675 char * kwnames[] = {
7676 (char *) "self",(char *) "r",(char *) "dir", NULL
7677 };
7678
7679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7681 if (!SWIG_IsOK(res1)) {
7682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7683 }
7684 arg1 = reinterpret_cast< wxRect * >(argp1);
7685 {
7686 arg2 = &temp2;
7687 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7688 }
7689 if (obj2) {
7690 ecode3 = SWIG_AsVal_int(obj2, &val3);
7691 if (!SWIG_IsOK(ecode3)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7693 }
7694 arg3 = static_cast< int >(val3);
7695 }
7696 {
7697 PyThreadState* __tstate = wxPyBeginAllowThreads();
7698 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7710 PyObject *resultobj = 0;
7711 wxRect *arg1 = (wxRect *) 0 ;
7712 int arg2 ;
7713 void *argp1 = 0 ;
7714 int res1 = 0 ;
7715 int val2 ;
7716 int ecode2 = 0 ;
7717 PyObject *swig_obj[2] ;
7718
7719 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7723 }
7724 arg1 = reinterpret_cast< wxRect * >(argp1);
7725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7728 }
7729 arg2 = static_cast< int >(val2);
7730 if (arg1) (arg1)->x = arg2;
7731
7732 resultobj = SWIG_Py_Void();
7733 return resultobj;
7734 fail:
7735 return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740 PyObject *resultobj = 0;
7741 wxRect *arg1 = (wxRect *) 0 ;
7742 int result;
7743 void *argp1 = 0 ;
7744 int res1 = 0 ;
7745 PyObject *swig_obj[1] ;
7746
7747 if (!args) SWIG_fail;
7748 swig_obj[0] = args;
7749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 result = (int) ((arg1)->x);
7755 resultobj = SWIG_From_int(static_cast< int >(result));
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 int arg2 ;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 int val2 ;
7769 int ecode2 = 0 ;
7770 PyObject *swig_obj[2] ;
7771
7772 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7776 }
7777 arg1 = reinterpret_cast< wxRect * >(argp1);
7778 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7781 }
7782 arg2 = static_cast< int >(val2);
7783 if (arg1) (arg1)->y = arg2;
7784
7785 resultobj = SWIG_Py_Void();
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxRect *arg1 = (wxRect *) 0 ;
7795 int result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 PyObject *swig_obj[1] ;
7799
7800 if (!args) SWIG_fail;
7801 swig_obj[0] = args;
7802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7803 if (!SWIG_IsOK(res1)) {
7804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7805 }
7806 arg1 = reinterpret_cast< wxRect * >(argp1);
7807 result = (int) ((arg1)->y);
7808 resultobj = SWIG_From_int(static_cast< int >(result));
7809 return resultobj;
7810 fail:
7811 return NULL;
7812 }
7813
7814
7815 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816 PyObject *resultobj = 0;
7817 wxRect *arg1 = (wxRect *) 0 ;
7818 int arg2 ;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 int val2 ;
7822 int ecode2 = 0 ;
7823 PyObject *swig_obj[2] ;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7829 }
7830 arg1 = reinterpret_cast< wxRect * >(argp1);
7831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7834 }
7835 arg2 = static_cast< int >(val2);
7836 if (arg1) (arg1)->width = arg2;
7837
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 PyObject *swig_obj[1] ;
7852
7853 if (!args) SWIG_fail;
7854 swig_obj[0] = args;
7855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7856 if (!SWIG_IsOK(res1)) {
7857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7858 }
7859 arg1 = reinterpret_cast< wxRect * >(argp1);
7860 result = (int) ((arg1)->width);
7861 resultobj = SWIG_From_int(static_cast< int >(result));
7862 return resultobj;
7863 fail:
7864 return NULL;
7865 }
7866
7867
7868 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7869 PyObject *resultobj = 0;
7870 wxRect *arg1 = (wxRect *) 0 ;
7871 int arg2 ;
7872 void *argp1 = 0 ;
7873 int res1 = 0 ;
7874 int val2 ;
7875 int ecode2 = 0 ;
7876 PyObject *swig_obj[2] ;
7877
7878 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7882 }
7883 arg1 = reinterpret_cast< wxRect * >(argp1);
7884 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7887 }
7888 arg2 = static_cast< int >(val2);
7889 if (arg1) (arg1)->height = arg2;
7890
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int result;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 PyObject *swig_obj[1] ;
7905
7906 if (!args) SWIG_fail;
7907 swig_obj[0] = args;
7908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7909 if (!SWIG_IsOK(res1)) {
7910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7911 }
7912 arg1 = reinterpret_cast< wxRect * >(argp1);
7913 result = (int) ((arg1)->height);
7914 resultobj = SWIG_From_int(static_cast< int >(result));
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = 0;
7923 wxRect *arg1 = (wxRect *) 0 ;
7924 int arg2 = (int) 0 ;
7925 int arg3 = (int) 0 ;
7926 int arg4 = (int) 0 ;
7927 int arg5 = (int) 0 ;
7928 void *argp1 = 0 ;
7929 int res1 = 0 ;
7930 int val2 ;
7931 int ecode2 = 0 ;
7932 int val3 ;
7933 int ecode3 = 0 ;
7934 int val4 ;
7935 int ecode4 = 0 ;
7936 int val5 ;
7937 int ecode5 = 0 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 PyObject * obj2 = 0 ;
7941 PyObject * obj3 = 0 ;
7942 PyObject * obj4 = 0 ;
7943 char * kwnames[] = {
7944 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7945 };
7946
7947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7949 if (!SWIG_IsOK(res1)) {
7950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7951 }
7952 arg1 = reinterpret_cast< wxRect * >(argp1);
7953 if (obj1) {
7954 ecode2 = SWIG_AsVal_int(obj1, &val2);
7955 if (!SWIG_IsOK(ecode2)) {
7956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7957 }
7958 arg2 = static_cast< int >(val2);
7959 }
7960 if (obj2) {
7961 ecode3 = SWIG_AsVal_int(obj2, &val3);
7962 if (!SWIG_IsOK(ecode3)) {
7963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7964 }
7965 arg3 = static_cast< int >(val3);
7966 }
7967 if (obj3) {
7968 ecode4 = SWIG_AsVal_int(obj3, &val4);
7969 if (!SWIG_IsOK(ecode4)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7971 }
7972 arg4 = static_cast< int >(val4);
7973 }
7974 if (obj4) {
7975 ecode5 = SWIG_AsVal_int(obj4, &val5);
7976 if (!SWIG_IsOK(ecode5)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7978 }
7979 arg5 = static_cast< int >(val5);
7980 }
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 PyObject *result = 0 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 PyObject *swig_obj[1] ;
8001
8002 if (!args) SWIG_fail;
8003 swig_obj[0] = args;
8004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8007 }
8008 arg1 = reinterpret_cast< wxRect * >(argp1);
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (PyObject *)wxRect_Get(arg1);
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = result;
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8023 PyObject *obj;
8024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8025 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8026 return SWIG_Py_Void();
8027 }
8028
8029 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 return SWIG_Python_InitShadowInstance(args);
8031 }
8032
8033 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxRect *arg1 = (wxRect *) 0 ;
8036 wxRect *arg2 = (wxRect *) 0 ;
8037 PyObject *result = 0 ;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 void *argp2 = 0 ;
8041 int res2 = 0 ;
8042 PyObject * obj0 = 0 ;
8043 PyObject * obj1 = 0 ;
8044 char * kwnames[] = {
8045 (char *) "r1",(char *) "r2", NULL
8046 };
8047
8048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8055 if (!SWIG_IsOK(res2)) {
8056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8057 }
8058 arg2 = reinterpret_cast< wxRect * >(argp2);
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 result = (PyObject *)wxIntersectRect(arg1,arg2);
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = result;
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = 0;
8075 double arg1 = (double) 0.0 ;
8076 double arg2 = (double) 0.0 ;
8077 wxPoint2D *result = 0 ;
8078 double val1 ;
8079 int ecode1 = 0 ;
8080 double val2 ;
8081 int ecode2 = 0 ;
8082 PyObject * obj0 = 0 ;
8083 PyObject * obj1 = 0 ;
8084 char * kwnames[] = {
8085 (char *) "x",(char *) "y", NULL
8086 };
8087
8088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8089 if (obj0) {
8090 ecode1 = SWIG_AsVal_double(obj0, &val1);
8091 if (!SWIG_IsOK(ecode1)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8093 }
8094 arg1 = static_cast< double >(val1);
8095 }
8096 if (obj1) {
8097 ecode2 = SWIG_AsVal_double(obj1, &val2);
8098 if (!SWIG_IsOK(ecode2)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8100 }
8101 arg2 = static_cast< double >(val2);
8102 }
8103 {
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj = 0;
8118 wxPoint2D *arg1 = 0 ;
8119 wxPoint2D *result = 0 ;
8120 wxPoint2D temp1 ;
8121 PyObject * obj0 = 0 ;
8122 char * kwnames[] = {
8123 (char *) "pt", NULL
8124 };
8125
8126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8127 {
8128 arg1 = &temp1;
8129 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8130 }
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8134 wxPyEndAllowThreads(__tstate);
8135 if (PyErr_Occurred()) SWIG_fail;
8136 }
8137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxPoint *arg1 = 0 ;
8147 wxPoint2D *result = 0 ;
8148 wxPoint temp1 ;
8149 PyObject * obj0 = 0 ;
8150 char * kwnames[] = {
8151 (char *) "pt", NULL
8152 };
8153
8154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8155 {
8156 arg1 = &temp1;
8157 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8158 }
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8162 wxPyEndAllowThreads(__tstate);
8163 if (PyErr_Occurred()) SWIG_fail;
8164 }
8165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8166 return resultobj;
8167 fail:
8168 return NULL;
8169 }
8170
8171
8172 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8173 PyObject *resultobj = 0;
8174 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8175 int *arg2 = (int *) 0 ;
8176 int *arg3 = (int *) 0 ;
8177 void *argp1 = 0 ;
8178 int res1 = 0 ;
8179 int temp2 ;
8180 int res2 = SWIG_TMPOBJ ;
8181 int temp3 ;
8182 int res3 = SWIG_TMPOBJ ;
8183 PyObject *swig_obj[1] ;
8184
8185 arg2 = &temp2;
8186 arg3 = &temp3;
8187 if (!args) SWIG_fail;
8188 swig_obj[0] = args;
8189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8190 if (!SWIG_IsOK(res1)) {
8191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8192 }
8193 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_Py_Void();
8201 if (SWIG_IsTmpObj(res2)) {
8202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8203 } else {
8204 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8206 }
8207 if (SWIG_IsTmpObj(res3)) {
8208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8209 } else {
8210 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8220 PyObject *resultobj = 0;
8221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8222 int *arg2 = (int *) 0 ;
8223 int *arg3 = (int *) 0 ;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 int temp2 ;
8227 int res2 = SWIG_TMPOBJ ;
8228 int temp3 ;
8229 int res3 = SWIG_TMPOBJ ;
8230 PyObject *swig_obj[1] ;
8231
8232 arg2 = &temp2;
8233 arg3 = &temp3;
8234 if (!args) SWIG_fail;
8235 swig_obj[0] = args;
8236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8237 if (!SWIG_IsOK(res1)) {
8238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8239 }
8240 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 resultobj = SWIG_Py_Void();
8248 if (SWIG_IsTmpObj(res2)) {
8249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8250 } else {
8251 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8253 }
8254 if (SWIG_IsTmpObj(res3)) {
8255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8256 } else {
8257 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8259 }
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *resultobj = 0;
8268 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8269 double result;
8270 void *argp1 = 0 ;
8271 int res1 = 0 ;
8272 PyObject *swig_obj[1] ;
8273
8274 if (!args) SWIG_fail;
8275 swig_obj[0] = args;
8276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8277 if (!SWIG_IsOK(res1)) {
8278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8279 }
8280 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = SWIG_From_double(static_cast< double >(result));
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8295 PyObject *resultobj = 0;
8296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8297 double result;
8298 void *argp1 = 0 ;
8299 int res1 = 0 ;
8300 PyObject *swig_obj[1] ;
8301
8302 if (!args) SWIG_fail;
8303 swig_obj[0] = args;
8304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8305 if (!SWIG_IsOK(res1)) {
8306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8307 }
8308 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_From_double(static_cast< double >(result));
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8325 double arg2 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 double val2 ;
8329 int ecode2 = 0 ;
8330 PyObject * obj0 = 0 ;
8331 PyObject * obj1 = 0 ;
8332 char * kwnames[] = {
8333 (char *) "self",(char *) "length", NULL
8334 };
8335
8336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8338 if (!SWIG_IsOK(res1)) {
8339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8340 }
8341 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8342 ecode2 = SWIG_AsVal_double(obj1, &val2);
8343 if (!SWIG_IsOK(ecode2)) {
8344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8345 }
8346 arg2 = static_cast< double >(val2);
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 (arg1)->SetVectorLength(arg2);
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_Py_Void();
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8363 double arg2 ;
8364 void *argp1 = 0 ;
8365 int res1 = 0 ;
8366 double val2 ;
8367 int ecode2 = 0 ;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char * kwnames[] = {
8371 (char *) "self",(char *) "degrees", NULL
8372 };
8373
8374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8376 if (!SWIG_IsOK(res1)) {
8377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8378 }
8379 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8380 ecode2 = SWIG_AsVal_double(obj1, &val2);
8381 if (!SWIG_IsOK(ecode2)) {
8382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8383 }
8384 arg2 = static_cast< double >(val2);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 (arg1)->SetVectorAngle(arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_Py_Void();
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "pt", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D *arg2 = 0 ;
8439 double result;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 wxPoint2D temp2 ;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char * kwnames[] = {
8446 (char *) "self",(char *) "pt", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 arg2 = &temp2;
8457 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8458 }
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_From_double(static_cast< double >(result));
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D *arg2 = 0 ;
8476 double result;
8477 void *argp1 = 0 ;
8478 int res1 = 0 ;
8479 wxPoint2D temp2 ;
8480 PyObject * obj0 = 0 ;
8481 PyObject * obj1 = 0 ;
8482 char * kwnames[] = {
8483 (char *) "self",(char *) "vec", NULL
8484 };
8485
8486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 arg2 = &temp2;
8494 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8495 }
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 resultobj = SWIG_From_double(static_cast< double >(result));
8503 return resultobj;
8504 fail:
8505 return NULL;
8506 }
8507
8508
8509 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = 0;
8511 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8512 wxPoint2D *arg2 = 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 wxPoint2D temp2 ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char * kwnames[] = {
8520 (char *) "self",(char *) "vec", NULL
8521 };
8522
8523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8527 }
8528 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8529 {
8530 arg2 = &temp2;
8531 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8532 }
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 wxPoint2D result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (arg1)->operator -();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 wxPoint2D *arg2 = 0 ;
8618 wxPoint2D *result = 0 ;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 wxPoint2D temp2 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "pt", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 {
8635 arg2 = &temp2;
8636 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8637 }
8638 {
8639 PyThreadState* __tstate = wxPyBeginAllowThreads();
8640 {
8641 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8642 result = (wxPoint2D *) &_result_ref;
8643 }
8644 wxPyEndAllowThreads(__tstate);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8648 return resultobj;
8649 fail:
8650 return NULL;
8651 }
8652
8653
8654 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8655 PyObject *resultobj = 0;
8656 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8657 wxPoint2D *arg2 = 0 ;
8658 wxPoint2D *result = 0 ;
8659 void *argp1 = 0 ;
8660 int res1 = 0 ;
8661 wxPoint2D temp2 ;
8662 PyObject * obj0 = 0 ;
8663 PyObject * obj1 = 0 ;
8664 char * kwnames[] = {
8665 (char *) "self",(char *) "pt", NULL
8666 };
8667
8668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8670 if (!SWIG_IsOK(res1)) {
8671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8672 }
8673 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8674 {
8675 arg2 = &temp2;
8676 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8677 }
8678 {
8679 PyThreadState* __tstate = wxPyBeginAllowThreads();
8680 {
8681 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8682 result = (wxPoint2D *) &_result_ref;
8683 }
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D *arg2 = 0 ;
8698 wxPoint2D *result = 0 ;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 wxPoint2D temp2 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "pt", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 {
8715 arg2 = &temp2;
8716 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8717 }
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 {
8721 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8722 result = (wxPoint2D *) &_result_ref;
8723 }
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8737 PyObject *arg2 = (PyObject *) 0 ;
8738 bool result;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 char * kwnames[] = {
8744 (char *) "self",(char *) "other", NULL
8745 };
8746
8747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8749 if (!SWIG_IsOK(res1)) {
8750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8751 }
8752 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8753 arg2 = obj1;
8754 {
8755 result = (bool)wxPoint2D___eq__(arg1,arg2);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 {
8759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8760 }
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 PyObject *arg2 = (PyObject *) 0 ;
8771 bool result;
8772 void *argp1 = 0 ;
8773 int res1 = 0 ;
8774 PyObject * obj0 = 0 ;
8775 PyObject * obj1 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "other", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 arg2 = obj1;
8787 {
8788 result = (bool)wxPoint2D___ne__(arg1,arg2);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 {
8792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8793 }
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 double arg2 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 PyObject *swig_obj[2] ;
8809
8810 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8817 if (!SWIG_IsOK(ecode2)) {
8818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8819 }
8820 arg2 = static_cast< double >(val2);
8821 if (arg1) (arg1)->m_x = arg2;
8822
8823 resultobj = SWIG_Py_Void();
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 double result;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 PyObject *swig_obj[1] ;
8837
8838 if (!args) SWIG_fail;
8839 swig_obj[0] = args;
8840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 result = (double) ((arg1)->m_x);
8846 resultobj = SWIG_From_double(static_cast< double >(result));
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 double arg2 ;
8857 void *argp1 = 0 ;
8858 int res1 = 0 ;
8859 double val2 ;
8860 int ecode2 = 0 ;
8861 PyObject *swig_obj[2] ;
8862
8863 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8867 }
8868 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8869 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8872 }
8873 arg2 = static_cast< double >(val2);
8874 if (arg1) (arg1)->m_y = arg2;
8875
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 double result;
8887 void *argp1 = 0 ;
8888 int res1 = 0 ;
8889 PyObject *swig_obj[1] ;
8890
8891 if (!args) SWIG_fail;
8892 swig_obj[0] = args;
8893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8894 if (!SWIG_IsOK(res1)) {
8895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 result = (double) ((arg1)->m_y);
8899 resultobj = SWIG_From_double(static_cast< double >(result));
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 double arg2 = (double) 0 ;
8910 double arg3 = (double) 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 double val2 ;
8914 int ecode2 = 0 ;
8915 double val3 ;
8916 int ecode3 = 0 ;
8917 PyObject * obj0 = 0 ;
8918 PyObject * obj1 = 0 ;
8919 PyObject * obj2 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "self",(char *) "x",(char *) "y", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8928 }
8929 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8930 if (obj1) {
8931 ecode2 = SWIG_AsVal_double(obj1, &val2);
8932 if (!SWIG_IsOK(ecode2)) {
8933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8934 }
8935 arg2 = static_cast< double >(val2);
8936 }
8937 if (obj2) {
8938 ecode3 = SWIG_AsVal_double(obj2, &val3);
8939 if (!SWIG_IsOK(ecode3)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8941 }
8942 arg3 = static_cast< double >(val3);
8943 }
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 wxPoint2D_Set(arg1,arg2,arg3);
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_Py_Void();
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958 PyObject *resultobj = 0;
8959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8960 PyObject *result = 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8972 {
8973 PyThreadState* __tstate = wxPyBeginAllowThreads();
8974 result = (PyObject *)wxPoint2D_Get(arg1);
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = result;
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8986 PyObject *obj;
8987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8989 return SWIG_Py_Void();
8990 }
8991
8992 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 return SWIG_Python_InitShadowInstance(args);
8994 }
8995
8996 SWIGINTERN int DefaultPosition_set(PyObject *) {
8997 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8998 return 1;
8999 }
9000
9001
9002 SWIGINTERN PyObject *DefaultPosition_get(void) {
9003 PyObject *pyobj = 0;
9004
9005 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9006 return pyobj;
9007 }
9008
9009
9010 SWIGINTERN int DefaultSize_set(PyObject *) {
9011 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9012 return 1;
9013 }
9014
9015
9016 SWIGINTERN PyObject *DefaultSize_get(void) {
9017 PyObject *pyobj = 0;
9018
9019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9020 return pyobj;
9021 }
9022
9023
9024 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj = 0;
9026 PyObject *arg1 = (PyObject *) 0 ;
9027 wxPyInputStream *result = 0 ;
9028 PyObject * obj0 = 0 ;
9029 char * kwnames[] = {
9030 (char *) "p", NULL
9031 };
9032
9033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9034 arg1 = obj0;
9035 {
9036 PyThreadState* __tstate = wxPyBeginAllowThreads();
9037 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject *swig_obj[1] ;
9054
9055 if (!args) SWIG_fail;
9056 swig_obj[0] = args;
9057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 {
9063 PyThreadState* __tstate = wxPyBeginAllowThreads();
9064 delete arg1;
9065
9066 wxPyEndAllowThreads(__tstate);
9067 if (PyErr_Occurred()) SWIG_fail;
9068 }
9069 resultobj = SWIG_Py_Void();
9070 return resultobj;
9071 fail:
9072 return NULL;
9073 }
9074
9075
9076 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9077 PyObject *resultobj = 0;
9078 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 PyObject *swig_obj[1] ;
9082
9083 if (!args) SWIG_fail;
9084 swig_obj[0] = args;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9090 {
9091 PyThreadState* __tstate = wxPyBeginAllowThreads();
9092 (arg1)->close();
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 resultobj = SWIG_Py_Void();
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *resultobj = 0;
9105 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 PyObject *swig_obj[1] ;
9109
9110 if (!args) SWIG_fail;
9111 swig_obj[0] = args;
9112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9113 if (!SWIG_IsOK(res1)) {
9114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9115 }
9116 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9117 {
9118 PyThreadState* __tstate = wxPyBeginAllowThreads();
9119 (arg1)->flush();
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_Py_Void();
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *resultobj = 0;
9132 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9133 bool result;
9134 void *argp1 = 0 ;
9135 int res1 = 0 ;
9136 PyObject *swig_obj[1] ;
9137
9138 if (!args) SWIG_fail;
9139 swig_obj[0] = args;
9140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9143 }
9144 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)(arg1)->eof();
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 {
9152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = 0;
9162 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9163 int arg2 = (int) -1 ;
9164 PyObject *result = 0 ;
9165 void *argp1 = 0 ;
9166 int res1 = 0 ;
9167 int val2 ;
9168 int ecode2 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "size", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_int(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9185 }
9186 arg2 = static_cast< int >(val2);
9187 }
9188 {
9189 PyThreadState* __tstate = wxPyBeginAllowThreads();
9190 result = (PyObject *)(arg1)->read(arg2);
9191 wxPyEndAllowThreads(__tstate);
9192 if (PyErr_Occurred()) SWIG_fail;
9193 }
9194 resultobj = result;
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj = 0;
9203 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9204 int arg2 = (int) -1 ;
9205 PyObject *result = 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 int val2 ;
9209 int ecode2 = 0 ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 char * kwnames[] = {
9213 (char *) "self",(char *) "size", NULL
9214 };
9215
9216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9218 if (!SWIG_IsOK(res1)) {
9219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9220 }
9221 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_int(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9226 }
9227 arg2 = static_cast< int >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (PyObject *)(arg1)->readline(arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = result;
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9243 PyObject *resultobj = 0;
9244 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9245 int arg2 = (int) -1 ;
9246 PyObject *result = 0 ;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 int val2 ;
9250 int ecode2 = 0 ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char * kwnames[] = {
9254 (char *) "self",(char *) "sizehint", NULL
9255 };
9256
9257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9259 if (!SWIG_IsOK(res1)) {
9260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9261 }
9262 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9263 if (obj1) {
9264 ecode2 = SWIG_AsVal_int(obj1, &val2);
9265 if (!SWIG_IsOK(ecode2)) {
9266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9267 }
9268 arg2 = static_cast< int >(val2);
9269 }
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 result = (PyObject *)(arg1)->readlines(arg2);
9273 wxPyEndAllowThreads(__tstate);
9274 if (PyErr_Occurred()) SWIG_fail;
9275 }
9276 resultobj = result;
9277 return resultobj;
9278 fail:
9279 return NULL;
9280 }
9281
9282
9283 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9284 PyObject *resultobj = 0;
9285 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9286 int arg2 ;
9287 int arg3 = (int) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 int val2 ;
9291 int ecode2 = 0 ;
9292 int val3 ;
9293 int ecode3 = 0 ;
9294 PyObject * obj0 = 0 ;
9295 PyObject * obj1 = 0 ;
9296 PyObject * obj2 = 0 ;
9297 char * kwnames[] = {
9298 (char *) "self",(char *) "offset",(char *) "whence", NULL
9299 };
9300
9301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9303 if (!SWIG_IsOK(res1)) {
9304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9305 }
9306 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9307 ecode2 = SWIG_AsVal_int(obj1, &val2);
9308 if (!SWIG_IsOK(ecode2)) {
9309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9310 }
9311 arg2 = static_cast< int >(val2);
9312 if (obj2) {
9313 ecode3 = SWIG_AsVal_int(obj2, &val3);
9314 if (!SWIG_IsOK(ecode3)) {
9315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9316 }
9317 arg3 = static_cast< int >(val3);
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 (arg1)->seek(arg2,arg3);
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 resultobj = SWIG_Py_Void();
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9333 PyObject *resultobj = 0;
9334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9335 int result;
9336 void *argp1 = 0 ;
9337 int res1 = 0 ;
9338 PyObject *swig_obj[1] ;
9339
9340 if (!args) SWIG_fail;
9341 swig_obj[0] = args;
9342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9345 }
9346 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9347 {
9348 PyThreadState* __tstate = wxPyBeginAllowThreads();
9349 result = (int)(arg1)->tell();
9350 wxPyEndAllowThreads(__tstate);
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_From_int(static_cast< int >(result));
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9363 char result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9373 }
9374 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (char)(arg1)->Peek();
9378 wxPyEndAllowThreads(__tstate);
9379 if (PyErr_Occurred()) SWIG_fail;
9380 }
9381 resultobj = SWIG_From_char(static_cast< char >(result));
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9389 PyObject *resultobj = 0;
9390 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9391 char result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 PyObject *swig_obj[1] ;
9395
9396 if (!args) SWIG_fail;
9397 swig_obj[0] = args;
9398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (char)(arg1)->GetC();
9406 wxPyEndAllowThreads(__tstate);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 resultobj = SWIG_From_char(static_cast< char >(result));
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 size_t result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (size_t)(arg1)->LastRead();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9438 return resultobj;
9439 fail:
9440 return NULL;
9441 }
9442
9443
9444 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9445 PyObject *resultobj = 0;
9446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9447 bool result;
9448 void *argp1 = 0 ;
9449 int res1 = 0 ;
9450 PyObject *swig_obj[1] ;
9451
9452 if (!args) SWIG_fail;
9453 swig_obj[0] = args;
9454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)(arg1)->CanRead();
9462 wxPyEndAllowThreads(__tstate);
9463 if (PyErr_Occurred()) SWIG_fail;
9464 }
9465 {
9466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9467 }
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9477 bool result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9487 }
9488 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9489 {
9490 PyThreadState* __tstate = wxPyBeginAllowThreads();
9491 result = (bool)(arg1)->Eof();
9492 wxPyEndAllowThreads(__tstate);
9493 if (PyErr_Occurred()) SWIG_fail;
9494 }
9495 {
9496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9497 }
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9507 char arg2 ;
9508 bool result;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 char val2 ;
9512 int ecode2 = 0 ;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 char * kwnames[] = {
9516 (char *) "self",(char *) "c", NULL
9517 };
9518
9519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9521 if (!SWIG_IsOK(res1)) {
9522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9523 }
9524 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9525 ecode2 = SWIG_AsVal_char(obj1, &val2);
9526 if (!SWIG_IsOK(ecode2)) {
9527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9528 }
9529 arg2 = static_cast< char >(val2);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (bool)(arg1)->Ungetch(arg2);
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 {
9537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9538 }
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9546 PyObject *resultobj = 0;
9547 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9548 long arg2 ;
9549 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9550 long result;
9551 void *argp1 = 0 ;
9552 int res1 = 0 ;
9553 long val2 ;
9554 int ecode2 = 0 ;
9555 int val3 ;
9556 int ecode3 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 char * kwnames[] = {
9561 (char *) "self",(char *) "pos",(char *) "mode", NULL
9562 };
9563
9564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9568 }
9569 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9570 ecode2 = SWIG_AsVal_long(obj1, &val2);
9571 if (!SWIG_IsOK(ecode2)) {
9572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9573 }
9574 arg2 = static_cast< long >(val2);
9575 if (obj2) {
9576 ecode3 = SWIG_AsVal_int(obj2, &val3);
9577 if (!SWIG_IsOK(ecode3)) {
9578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9579 }
9580 arg3 = static_cast< wxSeekMode >(val3);
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (long)(arg1)->SeekI(arg2,arg3);
9585 wxPyEndAllowThreads(__tstate);
9586 if (PyErr_Occurred()) SWIG_fail;
9587 }
9588 resultobj = SWIG_From_long(static_cast< long >(result));
9589 return resultobj;
9590 fail:
9591 return NULL;
9592 }
9593
9594
9595 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9596 PyObject *resultobj = 0;
9597 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9598 long result;
9599 void *argp1 = 0 ;
9600 int res1 = 0 ;
9601 PyObject *swig_obj[1] ;
9602
9603 if (!args) SWIG_fail;
9604 swig_obj[0] = args;
9605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9608 }
9609 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9610 {
9611 PyThreadState* __tstate = wxPyBeginAllowThreads();
9612 result = (long)(arg1)->TellI();
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_From_long(static_cast< long >(result));
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9624 PyObject *obj;
9625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9626 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9627 return SWIG_Py_Void();
9628 }
9629
9630 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9631 return SWIG_Python_InitShadowInstance(args);
9632 }
9633
9634 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9637 PyObject *arg2 = (PyObject *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "obj", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9652 arg2 = obj1;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 wxOutputStream_write(arg1,arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9669 size_t result;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9679 }
9680 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9688 return resultobj;
9689 fail:
9690 return NULL;
9691 }
9692
9693
9694 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 PyObject *obj;
9696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9697 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9698 return SWIG_Py_Void();
9699 }
9700
9701 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxInputStream *arg1 = (wxInputStream *) 0 ;
9704 wxString *arg2 = 0 ;
9705 wxString *arg3 = 0 ;
9706 wxString *arg4 = 0 ;
9707 wxDateTime arg5 ;
9708 wxFSFile *result = 0 ;
9709 wxPyInputStream *temp1 ;
9710 bool temp2 = false ;
9711 bool temp3 = false ;
9712 bool temp4 = false ;
9713 void *argp5 ;
9714 int res5 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 PyObject * obj2 = 0 ;
9718 PyObject * obj3 = 0 ;
9719 PyObject * obj4 = 0 ;
9720 char * kwnames[] = {
9721 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9722 };
9723
9724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9725 {
9726 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9727 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9728 } else {
9729 PyErr_Clear(); // clear the failure of the wxPyConvert above
9730 arg1 = wxPyCBInputStream_create(obj0, true);
9731 if (arg1 == NULL) {
9732 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9733 SWIG_fail;
9734 }
9735 }
9736 }
9737 {
9738 arg2 = wxString_in_helper(obj1);
9739 if (arg2 == NULL) SWIG_fail;
9740 temp2 = true;
9741 }
9742 {
9743 arg3 = wxString_in_helper(obj2);
9744 if (arg3 == NULL) SWIG_fail;
9745 temp3 = true;
9746 }
9747 {
9748 arg4 = wxString_in_helper(obj3);
9749 if (arg4 == NULL) SWIG_fail;
9750 temp4 = true;
9751 }
9752 {
9753 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9754 if (!SWIG_IsOK(res5)) {
9755 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9756 }
9757 if (!argp5) {
9758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9759 } else {
9760 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9761 arg5 = *temp;
9762 if (SWIG_IsNewObj(res5)) delete temp;
9763 }
9764 }
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9772 {
9773 if (temp2)
9774 delete arg2;
9775 }
9776 {
9777 if (temp3)
9778 delete arg3;
9779 }
9780 {
9781 if (temp4)
9782 delete arg4;
9783 }
9784 return resultobj;
9785 fail:
9786 {
9787 if (temp2)
9788 delete arg2;
9789 }
9790 {
9791 if (temp3)
9792 delete arg3;
9793 }
9794 {
9795 if (temp4)
9796 delete arg4;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9803 PyObject *resultobj = 0;
9804 wxFSFile *arg1 = (wxFSFile *) 0 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 PyObject *swig_obj[1] ;
9808
9809 if (!args) SWIG_fail;
9810 swig_obj[0] = args;
9811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9812 if (!SWIG_IsOK(res1)) {
9813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9814 }
9815 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9816 {
9817 PyThreadState* __tstate = wxPyBeginAllowThreads();
9818 delete arg1;
9819
9820 wxPyEndAllowThreads(__tstate);
9821 if (PyErr_Occurred()) SWIG_fail;
9822 }
9823 resultobj = SWIG_Py_Void();
9824 return resultobj;
9825 fail:
9826 return NULL;
9827 }
9828
9829
9830 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9831 PyObject *resultobj = 0;
9832 wxFSFile *arg1 = (wxFSFile *) 0 ;
9833 wxInputStream *result = 0 ;
9834 void *argp1 = 0 ;
9835 int res1 = 0 ;
9836 PyObject *swig_obj[1] ;
9837
9838 if (!args) SWIG_fail;
9839 swig_obj[0] = args;
9840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9841 if (!SWIG_IsOK(res1)) {
9842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9843 }
9844 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxInputStream *)(arg1)->GetStream();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 wxPyInputStream * _ptr = NULL;
9853
9854 if (result) {
9855 _ptr = new wxPyInputStream(result);
9856 }
9857 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 wxString *result = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9878 }
9879 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 {
9883 wxString const &_result_ref = (arg1)->GetMimeType();
9884 result = (wxString *) &_result_ref;
9885 }
9886 wxPyEndAllowThreads(__tstate);
9887 if (PyErr_Occurred()) SWIG_fail;
9888 }
9889 {
9890 #if wxUSE_UNICODE
9891 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9892 #else
9893 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9894 #endif
9895 }
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxFSFile *arg1 = (wxFSFile *) 0 ;
9905 wxString *result = 0 ;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9915 }
9916 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 {
9920 wxString const &_result_ref = (arg1)->GetLocation();
9921 result = (wxString *) &_result_ref;
9922 }
9923 wxPyEndAllowThreads(__tstate);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 {
9927 #if wxUSE_UNICODE
9928 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9929 #else
9930 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9931 #endif
9932 }
9933 return resultobj;
9934 fail:
9935 return NULL;
9936 }
9937
9938
9939 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9940 PyObject *resultobj = 0;
9941 wxFSFile *arg1 = (wxFSFile *) 0 ;
9942 wxString *result = 0 ;
9943 void *argp1 = 0 ;
9944 int res1 = 0 ;
9945 PyObject *swig_obj[1] ;
9946
9947 if (!args) SWIG_fail;
9948 swig_obj[0] = args;
9949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9950 if (!SWIG_IsOK(res1)) {
9951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9952 }
9953 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 {
9957 wxString const &_result_ref = (arg1)->GetAnchor();
9958 result = (wxString *) &_result_ref;
9959 }
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 #if wxUSE_UNICODE
9965 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9966 #else
9967 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9968 #endif
9969 }
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9977 PyObject *resultobj = 0;
9978 wxFSFile *arg1 = (wxFSFile *) 0 ;
9979 wxDateTime result;
9980 void *argp1 = 0 ;
9981 int res1 = 0 ;
9982 PyObject *swig_obj[1] ;
9983
9984 if (!args) SWIG_fail;
9985 swig_obj[0] = args;
9986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9987 if (!SWIG_IsOK(res1)) {
9988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9989 }
9990 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 result = (arg1)->GetModificationTime();
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *obj;
10006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10007 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10008 return SWIG_Py_Void();
10009 }
10010
10011 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10012 return SWIG_Python_InitShadowInstance(args);
10013 }
10014
10015 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10016 PyObject *resultobj = 0;
10017 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10018 void *argp1 = 0 ;
10019 int res1 = 0 ;
10020 PyObject *swig_obj[1] ;
10021
10022 if (!args) SWIG_fail;
10023 swig_obj[0] = args;
10024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10027 }
10028 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10029 {
10030 PyThreadState* __tstate = wxPyBeginAllowThreads();
10031 delete arg1;
10032
10033 wxPyEndAllowThreads(__tstate);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *obj;
10045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10046 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10047 return SWIG_Py_Void();
10048 }
10049
10050 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10051 PyObject *resultobj = 0;
10052 wxPyFileSystemHandler *result = 0 ;
10053
10054 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10071 PyObject *arg2 = (PyObject *) 0 ;
10072 PyObject *arg3 = (PyObject *) 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 PyObject * obj0 = 0 ;
10076 PyObject * obj1 = 0 ;
10077 PyObject * obj2 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "self",(char *) "_class", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10086 }
10087 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10088 arg2 = obj1;
10089 arg3 = obj2;
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 (arg1)->_setCallbackInfo(arg2,arg3);
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10106 wxString *arg2 = 0 ;
10107 bool result;
10108 void *argp1 = 0 ;
10109 int res1 = 0 ;
10110 bool temp2 = false ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 char * kwnames[] = {
10114 (char *) "self",(char *) "location", NULL
10115 };
10116
10117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10119 if (!SWIG_IsOK(res1)) {
10120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10121 }
10122 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10123 {
10124 arg2 = wxString_in_helper(obj1);
10125 if (arg2 == NULL) SWIG_fail;
10126 temp2 = true;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10131 wxPyEndAllowThreads(__tstate);
10132 if (PyErr_Occurred()) SWIG_fail;
10133 }
10134 {
10135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10136 }
10137 {
10138 if (temp2)
10139 delete arg2;
10140 }
10141 return resultobj;
10142 fail:
10143 {
10144 if (temp2)
10145 delete arg2;
10146 }
10147 return NULL;
10148 }
10149
10150
10151 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj = 0;
10153 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10154 wxFileSystem *arg2 = 0 ;
10155 wxString *arg3 = 0 ;
10156 wxFSFile *result = 0 ;
10157 void *argp1 = 0 ;
10158 int res1 = 0 ;
10159 void *argp2 = 0 ;
10160 int res2 = 0 ;
10161 bool temp3 = false ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 PyObject * obj2 = 0 ;
10165 char * kwnames[] = {
10166 (char *) "self",(char *) "fs",(char *) "location", NULL
10167 };
10168
10169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10173 }
10174 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10176 if (!SWIG_IsOK(res2)) {
10177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10178 }
10179 if (!argp2) {
10180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10181 }
10182 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10183 {
10184 arg3 = wxString_in_helper(obj2);
10185 if (arg3 == NULL) SWIG_fail;
10186 temp3 = true;
10187 }
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10196 }
10197 {
10198 if (temp3)
10199 delete arg3;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp3)
10205 delete arg3;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = 0;
10213 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10214 wxString *arg2 = 0 ;
10215 int arg3 = (int) 0 ;
10216 wxString result;
10217 void *argp1 = 0 ;
10218 int res1 = 0 ;
10219 bool temp2 = false ;
10220 int val3 ;
10221 int ecode3 = 0 ;
10222 PyObject * obj0 = 0 ;
10223 PyObject * obj1 = 0 ;
10224 PyObject * obj2 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "self",(char *) "spec",(char *) "flags", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10233 }
10234 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10235 {
10236 arg2 = wxString_in_helper(obj1);
10237 if (arg2 == NULL) SWIG_fail;
10238 temp2 = true;
10239 }
10240 if (obj2) {
10241 ecode3 = SWIG_AsVal_int(obj2, &val3);
10242 if (!SWIG_IsOK(ecode3)) {
10243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10244 }
10245 arg3 = static_cast< int >(val3);
10246 }
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10250 wxPyEndAllowThreads(__tstate);
10251 if (PyErr_Occurred()) SWIG_fail;
10252 }
10253 {
10254 #if wxUSE_UNICODE
10255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10256 #else
10257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10258 #endif
10259 }
10260 {
10261 if (temp2)
10262 delete arg2;
10263 }
10264 return resultobj;
10265 fail:
10266 {
10267 if (temp2)
10268 delete arg2;
10269 }
10270 return NULL;
10271 }
10272
10273
10274 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10275 PyObject *resultobj = 0;
10276 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10277 wxString result;
10278 void *argp1 = 0 ;
10279 int res1 = 0 ;
10280 PyObject *swig_obj[1] ;
10281
10282 if (!args) SWIG_fail;
10283 swig_obj[0] = args;
10284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10285 if (!SWIG_IsOK(res1)) {
10286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10287 }
10288 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10289 {
10290 PyThreadState* __tstate = wxPyBeginAllowThreads();
10291 result = (arg1)->FindNext();
10292 wxPyEndAllowThreads(__tstate);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 {
10296 #if wxUSE_UNICODE
10297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10298 #else
10299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10300 #endif
10301 }
10302 return resultobj;
10303 fail:
10304 return NULL;
10305 }
10306
10307
10308 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10309 PyObject *resultobj = 0;
10310 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10311 wxString *arg2 = 0 ;
10312 wxString result;
10313 void *argp1 = 0 ;
10314 int res1 = 0 ;
10315 bool temp2 = false ;
10316 PyObject * obj0 = 0 ;
10317 PyObject * obj1 = 0 ;
10318 char * kwnames[] = {
10319 (char *) "self",(char *) "location", NULL
10320 };
10321
10322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10324 if (!SWIG_IsOK(res1)) {
10325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10326 }
10327 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10328 {
10329 arg2 = wxString_in_helper(obj1);
10330 if (arg2 == NULL) SWIG_fail;
10331 temp2 = true;
10332 }
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (arg1)->GetProtocol((wxString const &)*arg2);
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 #if wxUSE_UNICODE
10341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10342 #else
10343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10344 #endif
10345 }
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return resultobj;
10351 fail:
10352 {
10353 if (temp2)
10354 delete arg2;
10355 }
10356 return NULL;
10357 }
10358
10359
10360 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj = 0;
10362 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10363 wxString *arg2 = 0 ;
10364 wxString result;
10365 void *argp1 = 0 ;
10366 int res1 = 0 ;
10367 bool temp2 = false ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char * kwnames[] = {
10371 (char *) "self",(char *) "location", NULL
10372 };
10373
10374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10376 if (!SWIG_IsOK(res1)) {
10377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10378 }
10379 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10380 {
10381 arg2 = wxString_in_helper(obj1);
10382 if (arg2 == NULL) SWIG_fail;
10383 temp2 = true;
10384 }
10385 {
10386 PyThreadState* __tstate = wxPyBeginAllowThreads();
10387 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10388 wxPyEndAllowThreads(__tstate);
10389 if (PyErr_Occurred()) SWIG_fail;
10390 }
10391 {
10392 #if wxUSE_UNICODE
10393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10394 #else
10395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10396 #endif
10397 }
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return resultobj;
10403 fail:
10404 {
10405 if (temp2)
10406 delete arg2;
10407 }
10408 return NULL;
10409 }
10410
10411
10412 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj = 0;
10414 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10415 wxString *arg2 = 0 ;
10416 wxString result;
10417 void *argp1 = 0 ;
10418 int res1 = 0 ;
10419 bool temp2 = false ;
10420 PyObject * obj0 = 0 ;
10421 PyObject * obj1 = 0 ;
10422 char * kwnames[] = {
10423 (char *) "self",(char *) "location", NULL
10424 };
10425
10426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10428 if (!SWIG_IsOK(res1)) {
10429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10430 }
10431 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10432 {
10433 arg2 = wxString_in_helper(obj1);
10434 if (arg2 == NULL) SWIG_fail;
10435 temp2 = true;
10436 }
10437 {
10438 PyThreadState* __tstate = wxPyBeginAllowThreads();
10439 result = (arg1)->GetAnchor((wxString const &)*arg2);
10440 wxPyEndAllowThreads(__tstate);
10441 if (PyErr_Occurred()) SWIG_fail;
10442 }
10443 {
10444 #if wxUSE_UNICODE
10445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10446 #else
10447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10448 #endif
10449 }
10450 {
10451 if (temp2)
10452 delete arg2;
10453 }
10454 return resultobj;
10455 fail:
10456 {
10457 if (temp2)
10458 delete arg2;
10459 }
10460 return NULL;
10461 }
10462
10463
10464 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj = 0;
10466 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10467 wxString *arg2 = 0 ;
10468 wxString result;
10469 void *argp1 = 0 ;
10470 int res1 = 0 ;
10471 bool temp2 = false ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 char * kwnames[] = {
10475 (char *) "self",(char *) "location", NULL
10476 };
10477
10478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10482 }
10483 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10484 {
10485 arg2 = wxString_in_helper(obj1);
10486 if (arg2 == NULL) SWIG_fail;
10487 temp2 = true;
10488 }
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 {
10496 #if wxUSE_UNICODE
10497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10498 #else
10499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10500 #endif
10501 }
10502 {
10503 if (temp2)
10504 delete arg2;
10505 }
10506 return resultobj;
10507 fail:
10508 {
10509 if (temp2)
10510 delete arg2;
10511 }
10512 return NULL;
10513 }
10514
10515
10516 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj = 0;
10518 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10519 wxString *arg2 = 0 ;
10520 wxString result;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 bool temp2 = false ;
10524 PyObject * obj0 = 0 ;
10525 PyObject * obj1 = 0 ;
10526 char * kwnames[] = {
10527 (char *) "self",(char *) "location", NULL
10528 };
10529
10530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10536 {
10537 arg2 = wxString_in_helper(obj1);
10538 if (arg2 == NULL) SWIG_fail;
10539 temp2 = true;
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 {
10548 #if wxUSE_UNICODE
10549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10550 #else
10551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10552 #endif
10553 }
10554 {
10555 if (temp2)
10556 delete arg2;
10557 }
10558 return resultobj;
10559 fail:
10560 {
10561 if (temp2)
10562 delete arg2;
10563 }
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *obj;
10570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10571 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10572 return SWIG_Py_Void();
10573 }
10574
10575 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10576 return SWIG_Python_InitShadowInstance(args);
10577 }
10578
10579 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10580 PyObject *resultobj = 0;
10581 wxFileSystem *result = 0 ;
10582
10583 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxFileSystem *)new wxFileSystem();
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 {
10591 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10592 }
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10600 PyObject *resultobj = 0;
10601 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 PyObject *swig_obj[1] ;
10605
10606 if (!args) SWIG_fail;
10607 swig_obj[0] = args;
10608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10611 }
10612 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 delete arg1;
10616
10617 wxPyEndAllowThreads(__tstate);
10618 if (PyErr_Occurred()) SWIG_fail;
10619 }
10620 resultobj = SWIG_Py_Void();
10621 return resultobj;
10622 fail:
10623 return NULL;
10624 }
10625
10626
10627 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10628 PyObject *resultobj = 0;
10629 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10630 wxString *arg2 = 0 ;
10631 bool arg3 = (bool) false ;
10632 void *argp1 = 0 ;
10633 int res1 = 0 ;
10634 bool temp2 = false ;
10635 bool val3 ;
10636 int ecode3 = 0 ;
10637 PyObject * obj0 = 0 ;
10638 PyObject * obj1 = 0 ;
10639 PyObject * obj2 = 0 ;
10640 char * kwnames[] = {
10641 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10642 };
10643
10644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10646 if (!SWIG_IsOK(res1)) {
10647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10648 }
10649 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10650 {
10651 arg2 = wxString_in_helper(obj1);
10652 if (arg2 == NULL) SWIG_fail;
10653 temp2 = true;
10654 }
10655 if (obj2) {
10656 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10657 if (!SWIG_IsOK(ecode3)) {
10658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10659 }
10660 arg3 = static_cast< bool >(val3);
10661 }
10662 {
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10665 wxPyEndAllowThreads(__tstate);
10666 if (PyErr_Occurred()) SWIG_fail;
10667 }
10668 resultobj = SWIG_Py_Void();
10669 {
10670 if (temp2)
10671 delete arg2;
10672 }
10673 return resultobj;
10674 fail:
10675 {
10676 if (temp2)
10677 delete arg2;
10678 }
10679 return NULL;
10680 }
10681
10682
10683 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10684 PyObject *resultobj = 0;
10685 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10686 wxString result;
10687 void *argp1 = 0 ;
10688 int res1 = 0 ;
10689 PyObject *swig_obj[1] ;
10690
10691 if (!args) SWIG_fail;
10692 swig_obj[0] = args;
10693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10694 if (!SWIG_IsOK(res1)) {
10695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10696 }
10697 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10698 {
10699 PyThreadState* __tstate = wxPyBeginAllowThreads();
10700 result = (arg1)->GetPath();
10701 wxPyEndAllowThreads(__tstate);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 {
10705 #if wxUSE_UNICODE
10706 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10707 #else
10708 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10709 #endif
10710 }
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10718 PyObject *resultobj = 0;
10719 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10720 wxString *arg2 = 0 ;
10721 wxFSFile *result = 0 ;
10722 void *argp1 = 0 ;
10723 int res1 = 0 ;
10724 bool temp2 = false ;
10725 PyObject * obj0 = 0 ;
10726 PyObject * obj1 = 0 ;
10727 char * kwnames[] = {
10728 (char *) "self",(char *) "location", NULL
10729 };
10730
10731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10733 if (!SWIG_IsOK(res1)) {
10734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10735 }
10736 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10737 {
10738 arg2 = wxString_in_helper(obj1);
10739 if (arg2 == NULL) SWIG_fail;
10740 temp2 = true;
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 {
10749 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10750 }
10751 {
10752 if (temp2)
10753 delete arg2;
10754 }
10755 return resultobj;
10756 fail:
10757 {
10758 if (temp2)
10759 delete arg2;
10760 }
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj = 0;
10767 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10768 wxString *arg2 = 0 ;
10769 int arg3 = (int) 0 ;
10770 wxString result;
10771 void *argp1 = 0 ;
10772 int res1 = 0 ;
10773 bool temp2 = false ;
10774 int val3 ;
10775 int ecode3 = 0 ;
10776 PyObject * obj0 = 0 ;
10777 PyObject * obj1 = 0 ;
10778 PyObject * obj2 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "spec",(char *) "flags", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10787 }
10788 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10789 {
10790 arg2 = wxString_in_helper(obj1);
10791 if (arg2 == NULL) SWIG_fail;
10792 temp2 = true;
10793 }
10794 if (obj2) {
10795 ecode3 = SWIG_AsVal_int(obj2, &val3);
10796 if (!SWIG_IsOK(ecode3)) {
10797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10798 }
10799 arg3 = static_cast< int >(val3);
10800 }
10801 {
10802 PyThreadState* __tstate = wxPyBeginAllowThreads();
10803 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10804 wxPyEndAllowThreads(__tstate);
10805 if (PyErr_Occurred()) SWIG_fail;
10806 }
10807 {
10808 #if wxUSE_UNICODE
10809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10810 #else
10811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10812 #endif
10813 }
10814 {
10815 if (temp2)
10816 delete arg2;
10817 }
10818 return resultobj;
10819 fail:
10820 {
10821 if (temp2)
10822 delete arg2;
10823 }
10824 return NULL;
10825 }
10826
10827
10828 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10829 PyObject *resultobj = 0;
10830 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10831 wxString result;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 PyObject *swig_obj[1] ;
10835
10836 if (!args) SWIG_fail;
10837 swig_obj[0] = args;
10838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10839 if (!SWIG_IsOK(res1)) {
10840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10841 }
10842 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10843 {
10844 PyThreadState* __tstate = wxPyBeginAllowThreads();
10845 result = (arg1)->FindNext();
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 {
10850 #if wxUSE_UNICODE
10851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10852 #else
10853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10854 #endif
10855 }
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj = 0;
10864 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10865 int res1 = 0 ;
10866 PyObject * obj0 = 0 ;
10867 char * kwnames[] = {
10868 (char *) "handler", NULL
10869 };
10870
10871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10872 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10873 if (!SWIG_IsOK(res1)) {
10874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10875 }
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 wxFileSystem::AddHandler(arg1);
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 resultobj = SWIG_Py_Void();
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 PyObject *resultobj = 0;
10891
10892 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10893 {
10894 PyThreadState* __tstate = wxPyBeginAllowThreads();
10895 wxFileSystem::CleanUpHandlers();
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_Py_Void();
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxString *arg1 = 0 ;
10909 wxString result;
10910 bool temp1 = false ;
10911 PyObject * obj0 = 0 ;
10912 char * kwnames[] = {
10913 (char *) "filename", NULL
10914 };
10915
10916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10917 {
10918 arg1 = wxString_in_helper(obj0);
10919 if (arg1 == NULL) SWIG_fail;
10920 temp1 = true;
10921 }
10922 {
10923 PyThreadState* __tstate = wxPyBeginAllowThreads();
10924 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10925 wxPyEndAllowThreads(__tstate);
10926 if (PyErr_Occurred()) SWIG_fail;
10927 }
10928 {
10929 #if wxUSE_UNICODE
10930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10931 #else
10932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10933 #endif
10934 }
10935 {
10936 if (temp1)
10937 delete arg1;
10938 }
10939 return resultobj;
10940 fail:
10941 {
10942 if (temp1)
10943 delete arg1;
10944 }
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj = 0;
10951 wxString *arg1 = 0 ;
10952 wxString result;
10953 bool temp1 = false ;
10954 PyObject * obj0 = 0 ;
10955 char * kwnames[] = {
10956 (char *) "url", NULL
10957 };
10958
10959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10960 {
10961 arg1 = wxString_in_helper(obj0);
10962 if (arg1 == NULL) SWIG_fail;
10963 temp1 = true;
10964 }
10965 {
10966 PyThreadState* __tstate = wxPyBeginAllowThreads();
10967 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10968 wxPyEndAllowThreads(__tstate);
10969 if (PyErr_Occurred()) SWIG_fail;
10970 }
10971 {
10972 #if wxUSE_UNICODE
10973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10974 #else
10975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10976 #endif
10977 }
10978 {
10979 if (temp1)
10980 delete arg1;
10981 }
10982 return resultobj;
10983 fail:
10984 {
10985 if (temp1)
10986 delete arg1;
10987 }
10988 return NULL;
10989 }
10990
10991
10992 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10993 PyObject *obj;
10994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10995 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10996 return SWIG_Py_Void();
10997 }
10998
10999 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11000 return SWIG_Python_InitShadowInstance(args);
11001 }
11002
11003 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 PyObject *resultobj = 0;
11005 wxInternetFSHandler *result = 0 ;
11006
11007 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11008 {
11009 PyThreadState* __tstate = wxPyBeginAllowThreads();
11010 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11011 wxPyEndAllowThreads(__tstate);
11012 if (PyErr_Occurred()) SWIG_fail;
11013 }
11014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11015 return resultobj;
11016 fail:
11017 return NULL;
11018 }
11019
11020
11021 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11022 PyObject *resultobj = 0;
11023 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11024 wxString *arg2 = 0 ;
11025 bool result;
11026 void *argp1 = 0 ;
11027 int res1 = 0 ;
11028 bool temp2 = false ;
11029 PyObject * obj0 = 0 ;
11030 PyObject * obj1 = 0 ;
11031 char * kwnames[] = {
11032 (char *) "self",(char *) "location", NULL
11033 };
11034
11035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11037 if (!SWIG_IsOK(res1)) {
11038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11039 }
11040 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11041 {
11042 arg2 = wxString_in_helper(obj1);
11043 if (arg2 == NULL) SWIG_fail;
11044 temp2 = true;
11045 }
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11049 wxPyEndAllowThreads(__tstate);
11050 if (PyErr_Occurred()) SWIG_fail;
11051 }
11052 {
11053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11054 }
11055 {
11056 if (temp2)
11057 delete arg2;
11058 }
11059 return resultobj;
11060 fail:
11061 {
11062 if (temp2)
11063 delete arg2;
11064 }
11065 return NULL;
11066 }
11067
11068
11069 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11070 PyObject *resultobj = 0;
11071 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11072 wxFileSystem *arg2 = 0 ;
11073 wxString *arg3 = 0 ;
11074 wxFSFile *result = 0 ;
11075 void *argp1 = 0 ;
11076 int res1 = 0 ;
11077 void *argp2 = 0 ;
11078 int res2 = 0 ;
11079 bool temp3 = false ;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 char * kwnames[] = {
11084 (char *) "self",(char *) "fs",(char *) "location", NULL
11085 };
11086
11087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11089 if (!SWIG_IsOK(res1)) {
11090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11091 }
11092 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11094 if (!SWIG_IsOK(res2)) {
11095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11096 }
11097 if (!argp2) {
11098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11099 }
11100 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11101 {
11102 arg3 = wxString_in_helper(obj2);
11103 if (arg3 == NULL) SWIG_fail;
11104 temp3 = true;
11105 }
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11114 }
11115 {
11116 if (temp3)
11117 delete arg3;
11118 }
11119 return resultobj;
11120 fail:
11121 {
11122 if (temp3)
11123 delete arg3;
11124 }
11125 return NULL;
11126 }
11127
11128
11129 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11130 PyObject *obj;
11131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11132 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11133 return SWIG_Py_Void();
11134 }
11135
11136 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11137 return SWIG_Python_InitShadowInstance(args);
11138 }
11139
11140 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxZipFSHandler *result = 0 ;
11143
11144 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (wxZipFSHandler *)new wxZipFSHandler();
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj = 0;
11160 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11161 wxString *arg2 = 0 ;
11162 bool result;
11163 void *argp1 = 0 ;
11164 int res1 = 0 ;
11165 bool temp2 = false ;
11166 PyObject * obj0 = 0 ;
11167 PyObject * obj1 = 0 ;
11168 char * kwnames[] = {
11169 (char *) "self",(char *) "location", NULL
11170 };
11171
11172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11174 if (!SWIG_IsOK(res1)) {
11175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11176 }
11177 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11178 {
11179 arg2 = wxString_in_helper(obj1);
11180 if (arg2 == NULL) SWIG_fail;
11181 temp2 = true;
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 {
11190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11191 }
11192 {
11193 if (temp2)
11194 delete arg2;
11195 }
11196 return resultobj;
11197 fail:
11198 {
11199 if (temp2)
11200 delete arg2;
11201 }
11202 return NULL;
11203 }
11204
11205
11206 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj = 0;
11208 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11209 wxFileSystem *arg2 = 0 ;
11210 wxString *arg3 = 0 ;
11211 wxFSFile *result = 0 ;
11212 void *argp1 = 0 ;
11213 int res1 = 0 ;
11214 void *argp2 = 0 ;
11215 int res2 = 0 ;
11216 bool temp3 = false ;
11217 PyObject * obj0 = 0 ;
11218 PyObject * obj1 = 0 ;
11219 PyObject * obj2 = 0 ;
11220 char * kwnames[] = {
11221 (char *) "self",(char *) "fs",(char *) "location", NULL
11222 };
11223
11224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11226 if (!SWIG_IsOK(res1)) {
11227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11228 }
11229 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11231 if (!SWIG_IsOK(res2)) {
11232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11233 }
11234 if (!argp2) {
11235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11236 }
11237 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11238 {
11239 arg3 = wxString_in_helper(obj2);
11240 if (arg3 == NULL) SWIG_fail;
11241 temp3 = true;
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11251 }
11252 {
11253 if (temp3)
11254 delete arg3;
11255 }
11256 return resultobj;
11257 fail:
11258 {
11259 if (temp3)
11260 delete arg3;
11261 }
11262 return NULL;
11263 }
11264
11265
11266 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11267 PyObject *resultobj = 0;
11268 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11269 wxString *arg2 = 0 ;
11270 int arg3 = (int) 0 ;
11271 wxString result;
11272 void *argp1 = 0 ;
11273 int res1 = 0 ;
11274 bool temp2 = false ;
11275 int val3 ;
11276 int ecode3 = 0 ;
11277 PyObject * obj0 = 0 ;
11278 PyObject * obj1 = 0 ;
11279 PyObject * obj2 = 0 ;
11280 char * kwnames[] = {
11281 (char *) "self",(char *) "spec",(char *) "flags", NULL
11282 };
11283
11284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11286 if (!SWIG_IsOK(res1)) {
11287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11288 }
11289 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11290 {
11291 arg2 = wxString_in_helper(obj1);
11292 if (arg2 == NULL) SWIG_fail;
11293 temp2 = true;
11294 }
11295 if (obj2) {
11296 ecode3 = SWIG_AsVal_int(obj2, &val3);
11297 if (!SWIG_IsOK(ecode3)) {
11298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11299 }
11300 arg3 = static_cast< int >(val3);
11301 }
11302 {
11303 PyThreadState* __tstate = wxPyBeginAllowThreads();
11304 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11305 wxPyEndAllowThreads(__tstate);
11306 if (PyErr_Occurred()) SWIG_fail;
11307 }
11308 {
11309 #if wxUSE_UNICODE
11310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11311 #else
11312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11313 #endif
11314 }
11315 {
11316 if (temp2)
11317 delete arg2;
11318 }
11319 return resultobj;
11320 fail:
11321 {
11322 if (temp2)
11323 delete arg2;
11324 }
11325 return NULL;
11326 }
11327
11328
11329 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11330 PyObject *resultobj = 0;
11331 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11332 wxString result;
11333 void *argp1 = 0 ;
11334 int res1 = 0 ;
11335 PyObject *swig_obj[1] ;
11336
11337 if (!args) SWIG_fail;
11338 swig_obj[0] = args;
11339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11340 if (!SWIG_IsOK(res1)) {
11341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11342 }
11343 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11344 {
11345 PyThreadState* __tstate = wxPyBeginAllowThreads();
11346 result = (arg1)->FindNext();
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 {
11351 #if wxUSE_UNICODE
11352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11353 #else
11354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11355 #endif
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11364 PyObject *obj;
11365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11366 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11367 return SWIG_Py_Void();
11368 }
11369
11370 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371 return SWIG_Python_InitShadowInstance(args);
11372 }
11373
11374 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11375 PyObject *resultobj = 0;
11376 wxString *arg1 = 0 ;
11377 wxImage *arg2 = 0 ;
11378 long arg3 ;
11379 bool temp1 = false ;
11380 void *argp2 = 0 ;
11381 int res2 = 0 ;
11382 long val3 ;
11383 int ecode3 = 0 ;
11384 PyObject * obj0 = 0 ;
11385 PyObject * obj1 = 0 ;
11386 PyObject * obj2 = 0 ;
11387 char * kwnames[] = {
11388 (char *) "filename",(char *) "image",(char *) "type", NULL
11389 };
11390
11391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11392 {
11393 arg1 = wxString_in_helper(obj0);
11394 if (arg1 == NULL) SWIG_fail;
11395 temp1 = true;
11396 }
11397 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11398 if (!SWIG_IsOK(res2)) {
11399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11400 }
11401 if (!argp2) {
11402 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11403 }
11404 arg2 = reinterpret_cast< wxImage * >(argp2);
11405 ecode3 = SWIG_AsVal_long(obj2, &val3);
11406 if (!SWIG_IsOK(ecode3)) {
11407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11408 }
11409 arg3 = static_cast< long >(val3);
11410 {
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11413 wxPyEndAllowThreads(__tstate);
11414 if (PyErr_Occurred()) SWIG_fail;
11415 }
11416 resultobj = SWIG_Py_Void();
11417 {
11418 if (temp1)
11419 delete arg1;
11420 }
11421 return resultobj;
11422 fail:
11423 {
11424 if (temp1)
11425 delete arg1;
11426 }
11427 return NULL;
11428 }
11429
11430
11431 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11432 PyObject *resultobj = 0;
11433 wxString *arg1 = 0 ;
11434 wxBitmap *arg2 = 0 ;
11435 long arg3 ;
11436 bool temp1 = false ;
11437 void *argp2 = 0 ;
11438 int res2 = 0 ;
11439 long val3 ;
11440 int ecode3 = 0 ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 PyObject * obj2 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11455 if (!SWIG_IsOK(res2)) {
11456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11457 }
11458 if (!argp2) {
11459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11460 }
11461 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11462 ecode3 = SWIG_AsVal_long(obj2, &val3);
11463 if (!SWIG_IsOK(ecode3)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11465 }
11466 arg3 = static_cast< long >(val3);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 {
11475 if (temp1)
11476 delete arg1;
11477 }
11478 return resultobj;
11479 fail:
11480 {
11481 if (temp1)
11482 delete arg1;
11483 }
11484 return NULL;
11485 }
11486
11487
11488 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11489 PyObject *resultobj = 0;
11490 wxString *arg1 = 0 ;
11491 PyObject *arg2 = (PyObject *) 0 ;
11492 bool temp1 = false ;
11493 PyObject * obj0 = 0 ;
11494 PyObject * obj1 = 0 ;
11495 char * kwnames[] = {
11496 (char *) "filename",(char *) "data", NULL
11497 };
11498
11499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11500 {
11501 arg1 = wxString_in_helper(obj0);
11502 if (arg1 == NULL) SWIG_fail;
11503 temp1 = true;
11504 }
11505 arg2 = obj1;
11506 {
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11509 wxPyEndAllowThreads(__tstate);
11510 if (PyErr_Occurred()) SWIG_fail;
11511 }
11512 resultobj = SWIG_Py_Void();
11513 {
11514 if (temp1)
11515 delete arg1;
11516 }
11517 return resultobj;
11518 fail:
11519 {
11520 if (temp1)
11521 delete arg1;
11522 }
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxMemoryFSHandler *result = 0 ;
11530
11531 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11539 return resultobj;
11540 fail:
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxString *arg1 = 0 ;
11548 bool temp1 = false ;
11549 PyObject * obj0 = 0 ;
11550 char * kwnames[] = {
11551 (char *) "filename", NULL
11552 };
11553
11554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11555 {
11556 arg1 = wxString_in_helper(obj0);
11557 if (arg1 == NULL) SWIG_fail;
11558 temp1 = true;
11559 }
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_Py_Void();
11567 {
11568 if (temp1)
11569 delete arg1;
11570 }
11571 return resultobj;
11572 fail:
11573 {
11574 if (temp1)
11575 delete arg1;
11576 }
11577 return NULL;
11578 }
11579
11580
11581 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11582 PyObject *resultobj = 0;
11583 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11584 wxString *arg2 = 0 ;
11585 bool result;
11586 void *argp1 = 0 ;
11587 int res1 = 0 ;
11588 bool temp2 = false ;
11589 PyObject * obj0 = 0 ;
11590 PyObject * obj1 = 0 ;
11591 char * kwnames[] = {
11592 (char *) "self",(char *) "location", NULL
11593 };
11594
11595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11597 if (!SWIG_IsOK(res1)) {
11598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11599 }
11600 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11601 {
11602 arg2 = wxString_in_helper(obj1);
11603 if (arg2 == NULL) SWIG_fail;
11604 temp2 = true;
11605 }
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11614 }
11615 {
11616 if (temp2)
11617 delete arg2;
11618 }
11619 return resultobj;
11620 fail:
11621 {
11622 if (temp2)
11623 delete arg2;
11624 }
11625 return NULL;
11626 }
11627
11628
11629 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj = 0;
11631 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11632 wxFileSystem *arg2 = 0 ;
11633 wxString *arg3 = 0 ;
11634 wxFSFile *result = 0 ;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 void *argp2 = 0 ;
11638 int res2 = 0 ;
11639 bool temp3 = false ;
11640 PyObject * obj0 = 0 ;
11641 PyObject * obj1 = 0 ;
11642 PyObject * obj2 = 0 ;
11643 char * kwnames[] = {
11644 (char *) "self",(char *) "fs",(char *) "location", NULL
11645 };
11646
11647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11654 if (!SWIG_IsOK(res2)) {
11655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11656 }
11657 if (!argp2) {
11658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11659 }
11660 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11661 {
11662 arg3 = wxString_in_helper(obj2);
11663 if (arg3 == NULL) SWIG_fail;
11664 temp3 = true;
11665 }
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11674 }
11675 {
11676 if (temp3)
11677 delete arg3;
11678 }
11679 return resultobj;
11680 fail:
11681 {
11682 if (temp3)
11683 delete arg3;
11684 }
11685 return NULL;
11686 }
11687
11688
11689 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj = 0;
11691 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11692 wxString *arg2 = 0 ;
11693 int arg3 = (int) 0 ;
11694 wxString result;
11695 void *argp1 = 0 ;
11696 int res1 = 0 ;
11697 bool temp2 = false ;
11698 int val3 ;
11699 int ecode3 = 0 ;
11700 PyObject * obj0 = 0 ;
11701 PyObject * obj1 = 0 ;
11702 PyObject * obj2 = 0 ;
11703 char * kwnames[] = {
11704 (char *) "self",(char *) "spec",(char *) "flags", NULL
11705 };
11706
11707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11709 if (!SWIG_IsOK(res1)) {
11710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11711 }
11712 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11713 {
11714 arg2 = wxString_in_helper(obj1);
11715 if (arg2 == NULL) SWIG_fail;
11716 temp2 = true;
11717 }
11718 if (obj2) {
11719 ecode3 = SWIG_AsVal_int(obj2, &val3);
11720 if (!SWIG_IsOK(ecode3)) {
11721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11722 }
11723 arg3 = static_cast< int >(val3);
11724 }
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 {
11732 #if wxUSE_UNICODE
11733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11734 #else
11735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11736 #endif
11737 }
11738 {
11739 if (temp2)
11740 delete arg2;
11741 }
11742 return resultobj;
11743 fail:
11744 {
11745 if (temp2)
11746 delete arg2;
11747 }
11748 return NULL;
11749 }
11750
11751
11752 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11753 PyObject *resultobj = 0;
11754 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11755 wxString result;
11756 void *argp1 = 0 ;
11757 int res1 = 0 ;
11758 PyObject *swig_obj[1] ;
11759
11760 if (!args) SWIG_fail;
11761 swig_obj[0] = args;
11762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11763 if (!SWIG_IsOK(res1)) {
11764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11765 }
11766 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (arg1)->FindNext();
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 #if wxUSE_UNICODE
11775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11776 #else
11777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11778 #endif
11779 }
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11787 PyObject *obj;
11788 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11789 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11790 return SWIG_Py_Void();
11791 }
11792
11793 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 return SWIG_Python_InitShadowInstance(args);
11795 }
11796
11797 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798 PyObject *resultobj = 0;
11799 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11800 wxString result;
11801 void *argp1 = 0 ;
11802 int res1 = 0 ;
11803 PyObject *swig_obj[1] ;
11804
11805 if (!args) SWIG_fail;
11806 swig_obj[0] = args;
11807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11808 if (!SWIG_IsOK(res1)) {
11809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11810 }
11811 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 result = (arg1)->GetName();
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 {
11819 #if wxUSE_UNICODE
11820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11821 #else
11822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11823 #endif
11824 }
11825 return resultobj;
11826 fail:
11827 return NULL;
11828 }
11829
11830
11831 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11832 PyObject *resultobj = 0;
11833 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11834 wxString result;
11835 void *argp1 = 0 ;
11836 int res1 = 0 ;
11837 PyObject *swig_obj[1] ;
11838
11839 if (!args) SWIG_fail;
11840 swig_obj[0] = args;
11841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11842 if (!SWIG_IsOK(res1)) {
11843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11844 }
11845 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 result = (arg1)->GetExtension();
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 #if wxUSE_UNICODE
11854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11855 #else
11856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11857 #endif
11858 }
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11866 PyObject *resultobj = 0;
11867 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11868 long result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 PyObject *swig_obj[1] ;
11872
11873 if (!args) SWIG_fail;
11874 swig_obj[0] = args;
11875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11878 }
11879 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (long)(arg1)->GetType();
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_From_long(static_cast< long >(result));
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *resultobj = 0;
11895 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11896 wxString result;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 PyObject *swig_obj[1] ;
11900
11901 if (!args) SWIG_fail;
11902 swig_obj[0] = args;
11903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11906 }
11907 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (arg1)->GetMimeType();
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 #if wxUSE_UNICODE
11916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11917 #else
11918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11919 #endif
11920 }
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11928 PyObject *resultobj = 0;
11929 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11930 wxString *arg2 = 0 ;
11931 bool result;
11932 void *argp1 = 0 ;
11933 int res1 = 0 ;
11934 bool temp2 = false ;
11935 PyObject * obj0 = 0 ;
11936 PyObject * obj1 = 0 ;
11937 char * kwnames[] = {
11938 (char *) "self",(char *) "name", NULL
11939 };
11940
11941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11943 if (!SWIG_IsOK(res1)) {
11944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11945 }
11946 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11947 {
11948 arg2 = wxString_in_helper(obj1);
11949 if (arg2 == NULL) SWIG_fail;
11950 temp2 = true;
11951 }
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11960 }
11961 {
11962 if (temp2)
11963 delete arg2;
11964 }
11965 return resultobj;
11966 fail:
11967 {
11968 if (temp2)
11969 delete arg2;
11970 }
11971 return NULL;
11972 }
11973
11974
11975 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj = 0;
11977 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11978 wxInputStream *arg2 = 0 ;
11979 bool result;
11980 void *argp1 = 0 ;
11981 int res1 = 0 ;
11982 wxPyInputStream *temp2 ;
11983 bool created2 ;
11984 PyObject * obj0 = 0 ;
11985 PyObject * obj1 = 0 ;
11986 char * kwnames[] = {
11987 (char *) "self",(char *) "stream", NULL
11988 };
11989
11990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11994 }
11995 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11996 {
11997 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11998 arg2 = temp2->m_wxis;
11999 created2 = false;
12000 } else {
12001 PyErr_Clear(); // clear the failure of the wxPyConvert above
12002 arg2 = wxPyCBInputStream_create(obj1, false);
12003 if (arg2 == NULL) {
12004 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12005 SWIG_fail;
12006 }
12007 created2 = true;
12008 }
12009 }
12010 {
12011 PyThreadState* __tstate = wxPyBeginAllowThreads();
12012 result = (bool)(arg1)->CanRead(*arg2);
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 {
12017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12018 }
12019 {
12020 if (created2) delete arg2;
12021 }
12022 return resultobj;
12023 fail:
12024 {
12025 if (created2) delete arg2;
12026 }
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj = 0;
12033 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12034 wxString *arg2 = 0 ;
12035 void *argp1 = 0 ;
12036 int res1 = 0 ;
12037 bool temp2 = false ;
12038 PyObject * obj0 = 0 ;
12039 PyObject * obj1 = 0 ;
12040 char * kwnames[] = {
12041 (char *) "self",(char *) "name", NULL
12042 };
12043
12044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12046 if (!SWIG_IsOK(res1)) {
12047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12048 }
12049 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12050 {
12051 arg2 = wxString_in_helper(obj1);
12052 if (arg2 == NULL) SWIG_fail;
12053 temp2 = true;
12054 }
12055 {
12056 PyThreadState* __tstate = wxPyBeginAllowThreads();
12057 (arg1)->SetName((wxString const &)*arg2);
12058 wxPyEndAllowThreads(__tstate);
12059 if (PyErr_Occurred()) SWIG_fail;
12060 }
12061 resultobj = SWIG_Py_Void();
12062 {
12063 if (temp2)
12064 delete arg2;
12065 }
12066 return resultobj;
12067 fail:
12068 {
12069 if (temp2)
12070 delete arg2;
12071 }
12072 return NULL;
12073 }
12074
12075
12076 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj = 0;
12078 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12079 wxString *arg2 = 0 ;
12080 void *argp1 = 0 ;
12081 int res1 = 0 ;
12082 bool temp2 = false ;
12083 PyObject * obj0 = 0 ;
12084 PyObject * obj1 = 0 ;
12085 char * kwnames[] = {
12086 (char *) "self",(char *) "extension", NULL
12087 };
12088
12089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12091 if (!SWIG_IsOK(res1)) {
12092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12093 }
12094 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12095 {
12096 arg2 = wxString_in_helper(obj1);
12097 if (arg2 == NULL) SWIG_fail;
12098 temp2 = true;
12099 }
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 (arg1)->SetExtension((wxString const &)*arg2);
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 resultobj = SWIG_Py_Void();
12107 {
12108 if (temp2)
12109 delete arg2;
12110 }
12111 return resultobj;
12112 fail:
12113 {
12114 if (temp2)
12115 delete arg2;
12116 }
12117 return NULL;
12118 }
12119
12120
12121 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12122 PyObject *resultobj = 0;
12123 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12124 long arg2 ;
12125 void *argp1 = 0 ;
12126 int res1 = 0 ;
12127 long val2 ;
12128 int ecode2 = 0 ;
12129 PyObject * obj0 = 0 ;
12130 PyObject * obj1 = 0 ;
12131 char * kwnames[] = {
12132 (char *) "self",(char *) "type", NULL
12133 };
12134
12135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12137 if (!SWIG_IsOK(res1)) {
12138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12139 }
12140 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12141 ecode2 = SWIG_AsVal_long(obj1, &val2);
12142 if (!SWIG_IsOK(ecode2)) {
12143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12144 }
12145 arg2 = static_cast< long >(val2);
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 (arg1)->SetType(arg2);
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 resultobj = SWIG_Py_Void();
12153 return resultobj;
12154 fail:
12155 return NULL;
12156 }
12157
12158
12159 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12160 PyObject *resultobj = 0;
12161 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12162 wxString *arg2 = 0 ;
12163 void *argp1 = 0 ;
12164 int res1 = 0 ;
12165 bool temp2 = false ;
12166 PyObject * obj0 = 0 ;
12167 PyObject * obj1 = 0 ;
12168 char * kwnames[] = {
12169 (char *) "self",(char *) "mimetype", NULL
12170 };
12171
12172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12174 if (!SWIG_IsOK(res1)) {
12175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12176 }
12177 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12178 {
12179 arg2 = wxString_in_helper(obj1);
12180 if (arg2 == NULL) SWIG_fail;
12181 temp2 = true;
12182 }
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 (arg1)->SetMimeType((wxString const &)*arg2);
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 resultobj = SWIG_Py_Void();
12190 {
12191 if (temp2)
12192 delete arg2;
12193 }
12194 return resultobj;
12195 fail:
12196 {
12197 if (temp2)
12198 delete arg2;
12199 }
12200 return NULL;
12201 }
12202
12203
12204 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12205 PyObject *obj;
12206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12207 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12208 return SWIG_Py_Void();
12209 }
12210
12211 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12212 PyObject *resultobj = 0;
12213 wxPyImageHandler *result = 0 ;
12214
12215 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 result = (wxPyImageHandler *)new wxPyImageHandler();
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj = 0;
12231 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12232 PyObject *arg2 = (PyObject *) 0 ;
12233 void *argp1 = 0 ;
12234 int res1 = 0 ;
12235 PyObject * obj0 = 0 ;
12236 PyObject * obj1 = 0 ;
12237 char * kwnames[] = {
12238 (char *) "self",(char *) "self", NULL
12239 };
12240
12241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12243 if (!SWIG_IsOK(res1)) {
12244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12245 }
12246 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12247 arg2 = obj1;
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 (arg1)->_SetSelf(arg2);
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 resultobj = SWIG_Py_Void();
12255 return resultobj;
12256 fail:
12257 return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12262 PyObject *obj;
12263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12264 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12265 return SWIG_Py_Void();
12266 }
12267
12268 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 return SWIG_Python_InitShadowInstance(args);
12270 }
12271
12272 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12273 PyObject *resultobj = 0;
12274 wxImageHistogram *result = 0 ;
12275
12276 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 result = (wxImageHistogram *)new wxImageHistogram();
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12291 PyObject *resultobj = 0;
12292 byte arg1 ;
12293 byte arg2 ;
12294 byte arg3 ;
12295 unsigned long result;
12296 unsigned char val1 ;
12297 int ecode1 = 0 ;
12298 unsigned char val2 ;
12299 int ecode2 = 0 ;
12300 unsigned char val3 ;
12301 int ecode3 = 0 ;
12302 PyObject * obj0 = 0 ;
12303 PyObject * obj1 = 0 ;
12304 PyObject * obj2 = 0 ;
12305 char * kwnames[] = {
12306 (char *) "r",(char *) "g",(char *) "b", NULL
12307 };
12308
12309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12310 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12311 if (!SWIG_IsOK(ecode1)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12313 }
12314 arg1 = static_cast< byte >(val1);
12315 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12316 if (!SWIG_IsOK(ecode2)) {
12317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12318 }
12319 arg2 = static_cast< byte >(val2);
12320 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12321 if (!SWIG_IsOK(ecode3)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12323 }
12324 arg3 = static_cast< byte >(val3);
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12339 PyObject *resultobj = 0;
12340 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12341 byte *arg2 = (byte *) 0 ;
12342 byte *arg3 = (byte *) 0 ;
12343 byte *arg4 = (byte *) 0 ;
12344 byte arg5 = (byte) 1 ;
12345 byte arg6 = (byte) 0 ;
12346 byte arg7 = (byte) 0 ;
12347 bool result;
12348 void *argp1 = 0 ;
12349 int res1 = 0 ;
12350 byte temp2 ;
12351 int res2 = SWIG_TMPOBJ ;
12352 byte temp3 ;
12353 int res3 = SWIG_TMPOBJ ;
12354 byte temp4 ;
12355 int res4 = SWIG_TMPOBJ ;
12356 unsigned char val5 ;
12357 int ecode5 = 0 ;
12358 unsigned char val6 ;
12359 int ecode6 = 0 ;
12360 unsigned char val7 ;
12361 int ecode7 = 0 ;
12362 PyObject * obj0 = 0 ;
12363 PyObject * obj1 = 0 ;
12364 PyObject * obj2 = 0 ;
12365 PyObject * obj3 = 0 ;
12366 char * kwnames[] = {
12367 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12368 };
12369
12370 arg2 = &temp2;
12371 arg3 = &temp3;
12372 arg4 = &temp4;
12373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12377 }
12378 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12379 if (obj1) {
12380 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12381 if (!SWIG_IsOK(ecode5)) {
12382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12383 }
12384 arg5 = static_cast< byte >(val5);
12385 }
12386 if (obj2) {
12387 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12388 if (!SWIG_IsOK(ecode6)) {
12389 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12390 }
12391 arg6 = static_cast< byte >(val6);
12392 }
12393 if (obj3) {
12394 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12395 if (!SWIG_IsOK(ecode7)) {
12396 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12397 }
12398 arg7 = static_cast< byte >(val7);
12399 }
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 {
12407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12408 }
12409 if (SWIG_IsTmpObj(res2)) {
12410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12411 } else {
12412 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12414 }
12415 if (SWIG_IsTmpObj(res3)) {
12416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12417 } else {
12418 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12420 }
12421 if (SWIG_IsTmpObj(res4)) {
12422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12423 } else {
12424 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12426 }
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = 0;
12435 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12436 unsigned long arg2 ;
12437 unsigned long result;
12438 void *argp1 = 0 ;
12439 int res1 = 0 ;
12440 unsigned long val2 ;
12441 int ecode2 = 0 ;
12442 PyObject * obj0 = 0 ;
12443 PyObject * obj1 = 0 ;
12444 char * kwnames[] = {
12445 (char *) "self",(char *) "key", NULL
12446 };
12447
12448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12450 if (!SWIG_IsOK(res1)) {
12451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12452 }
12453 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12454 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12455 if (!SWIG_IsOK(ecode2)) {
12456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12457 }
12458 arg2 = static_cast< unsigned long >(val2);
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj = 0;
12474 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12475 byte arg2 ;
12476 byte arg3 ;
12477 byte arg4 ;
12478 unsigned long result;
12479 void *argp1 = 0 ;
12480 int res1 = 0 ;
12481 unsigned char val2 ;
12482 int ecode2 = 0 ;
12483 unsigned char val3 ;
12484 int ecode3 = 0 ;
12485 unsigned char val4 ;
12486 int ecode4 = 0 ;
12487 PyObject * obj0 = 0 ;
12488 PyObject * obj1 = 0 ;
12489 PyObject * obj2 = 0 ;
12490 PyObject * obj3 = 0 ;
12491 char * kwnames[] = {
12492 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12493 };
12494
12495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12497 if (!SWIG_IsOK(res1)) {
12498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12499 }
12500 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12501 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12502 if (!SWIG_IsOK(ecode2)) {
12503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12504 }
12505 arg2 = static_cast< byte >(val2);
12506 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12507 if (!SWIG_IsOK(ecode3)) {
12508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12509 }
12510 arg3 = static_cast< byte >(val3);
12511 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12512 if (!SWIG_IsOK(ecode4)) {
12513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12514 }
12515 arg4 = static_cast< byte >(val4);
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12519 wxPyEndAllowThreads(__tstate);
12520 if (PyErr_Occurred()) SWIG_fail;
12521 }
12522 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = 0;
12531 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12532 wxColour *arg2 = 0 ;
12533 unsigned long result;
12534 void *argp1 = 0 ;
12535 int res1 = 0 ;
12536 wxColour temp2 ;
12537 PyObject * obj0 = 0 ;
12538 PyObject * obj1 = 0 ;
12539 char * kwnames[] = {
12540 (char *) "self",(char *) "colour", NULL
12541 };
12542
12543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12545 if (!SWIG_IsOK(res1)) {
12546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12547 }
12548 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12549 {
12550 arg2 = &temp2;
12551 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12552 }
12553 {
12554 PyThreadState* __tstate = wxPyBeginAllowThreads();
12555 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12556 wxPyEndAllowThreads(__tstate);
12557 if (PyErr_Occurred()) SWIG_fail;
12558 }
12559 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12567 PyObject *obj;
12568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12569 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12570 return SWIG_Py_Void();
12571 }
12572
12573 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574 return SWIG_Python_InitShadowInstance(args);
12575 }
12576
12577 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj = 0;
12579 byte arg1 = (byte) 0 ;
12580 byte arg2 = (byte) 0 ;
12581 byte arg3 = (byte) 0 ;
12582 wxImage_RGBValue *result = 0 ;
12583 unsigned char val1 ;
12584 int ecode1 = 0 ;
12585 unsigned char val2 ;
12586 int ecode2 = 0 ;
12587 unsigned char val3 ;
12588 int ecode3 = 0 ;
12589 PyObject * obj0 = 0 ;
12590 PyObject * obj1 = 0 ;
12591 PyObject * obj2 = 0 ;
12592 char * kwnames[] = {
12593 (char *) "r",(char *) "g",(char *) "b", NULL
12594 };
12595
12596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12597 if (obj0) {
12598 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12599 if (!SWIG_IsOK(ecode1)) {
12600 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12601 }
12602 arg1 = static_cast< byte >(val1);
12603 }
12604 if (obj1) {
12605 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12606 if (!SWIG_IsOK(ecode2)) {
12607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12608 }
12609 arg2 = static_cast< byte >(val2);
12610 }
12611 if (obj2) {
12612 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12613 if (!SWIG_IsOK(ecode3)) {
12614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12615 }
12616 arg3 = static_cast< byte >(val3);
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 PyObject *resultobj = 0;
12633 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12634 byte arg2 ;
12635 void *argp1 = 0 ;
12636 int res1 = 0 ;
12637 unsigned char val2 ;
12638 int ecode2 = 0 ;
12639 PyObject *swig_obj[2] ;
12640
12641 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12643 if (!SWIG_IsOK(res1)) {
12644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12645 }
12646 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12647 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12648 if (!SWIG_IsOK(ecode2)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12650 }
12651 arg2 = static_cast< byte >(val2);
12652 if (arg1) (arg1)->red = arg2;
12653
12654 resultobj = SWIG_Py_Void();
12655 return resultobj;
12656 fail:
12657 return NULL;
12658 }
12659
12660
12661 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12662 PyObject *resultobj = 0;
12663 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12664 byte result;
12665 void *argp1 = 0 ;
12666 int res1 = 0 ;
12667 PyObject *swig_obj[1] ;
12668
12669 if (!args) SWIG_fail;
12670 swig_obj[0] = args;
12671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12672 if (!SWIG_IsOK(res1)) {
12673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12674 }
12675 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12676 result = (byte) ((arg1)->red);
12677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *resultobj = 0;
12686 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12687 byte arg2 ;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 unsigned char val2 ;
12691 int ecode2 = 0 ;
12692 PyObject *swig_obj[2] ;
12693
12694 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12696 if (!SWIG_IsOK(res1)) {
12697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12698 }
12699 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12700 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12701 if (!SWIG_IsOK(ecode2)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12703 }
12704 arg2 = static_cast< byte >(val2);
12705 if (arg1) (arg1)->green = arg2;
12706
12707 resultobj = SWIG_Py_Void();
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12715 PyObject *resultobj = 0;
12716 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12717 byte result;
12718 void *argp1 = 0 ;
12719 int res1 = 0 ;
12720 PyObject *swig_obj[1] ;
12721
12722 if (!args) SWIG_fail;
12723 swig_obj[0] = args;
12724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12725 if (!SWIG_IsOK(res1)) {
12726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12727 }
12728 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12729 result = (byte) ((arg1)->green);
12730 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 PyObject *resultobj = 0;
12739 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12740 byte arg2 ;
12741 void *argp1 = 0 ;
12742 int res1 = 0 ;
12743 unsigned char val2 ;
12744 int ecode2 = 0 ;
12745 PyObject *swig_obj[2] ;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12749 if (!SWIG_IsOK(res1)) {
12750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12751 }
12752 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12753 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12754 if (!SWIG_IsOK(ecode2)) {
12755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12756 }
12757 arg2 = static_cast< byte >(val2);
12758 if (arg1) (arg1)->blue = arg2;
12759
12760 resultobj = SWIG_Py_Void();
12761 return resultobj;
12762 fail:
12763 return NULL;
12764 }
12765
12766
12767 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12768 PyObject *resultobj = 0;
12769 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12770 byte result;
12771 void *argp1 = 0 ;
12772 int res1 = 0 ;
12773 PyObject *swig_obj[1] ;
12774
12775 if (!args) SWIG_fail;
12776 swig_obj[0] = args;
12777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12778 if (!SWIG_IsOK(res1)) {
12779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12780 }
12781 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12782 result = (byte) ((arg1)->blue);
12783 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12791 PyObject *obj;
12792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12793 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12794 return SWIG_Py_Void();
12795 }
12796
12797 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798 return SWIG_Python_InitShadowInstance(args);
12799 }
12800
12801 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12802 PyObject *resultobj = 0;
12803 double arg1 = (double) 0.0 ;
12804 double arg2 = (double) 0.0 ;
12805 double arg3 = (double) 0.0 ;
12806 wxImage_HSVValue *result = 0 ;
12807 double val1 ;
12808 int ecode1 = 0 ;
12809 double val2 ;
12810 int ecode2 = 0 ;
12811 double val3 ;
12812 int ecode3 = 0 ;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 PyObject * obj2 = 0 ;
12816 char * kwnames[] = {
12817 (char *) "h",(char *) "s",(char *) "v", NULL
12818 };
12819
12820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12821 if (obj0) {
12822 ecode1 = SWIG_AsVal_double(obj0, &val1);
12823 if (!SWIG_IsOK(ecode1)) {
12824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12825 }
12826 arg1 = static_cast< double >(val1);
12827 }
12828 if (obj1) {
12829 ecode2 = SWIG_AsVal_double(obj1, &val2);
12830 if (!SWIG_IsOK(ecode2)) {
12831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12832 }
12833 arg2 = static_cast< double >(val2);
12834 }
12835 if (obj2) {
12836 ecode3 = SWIG_AsVal_double(obj2, &val3);
12837 if (!SWIG_IsOK(ecode3)) {
12838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12839 }
12840 arg3 = static_cast< double >(val3);
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12845 wxPyEndAllowThreads(__tstate);
12846 if (PyErr_Occurred()) SWIG_fail;
12847 }
12848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12849 return resultobj;
12850 fail:
12851 return NULL;
12852 }
12853
12854
12855 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 PyObject *resultobj = 0;
12857 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12858 double arg2 ;
12859 void *argp1 = 0 ;
12860 int res1 = 0 ;
12861 double val2 ;
12862 int ecode2 = 0 ;
12863 PyObject *swig_obj[2] ;
12864
12865 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12867 if (!SWIG_IsOK(res1)) {
12868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12869 }
12870 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12871 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12872 if (!SWIG_IsOK(ecode2)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12874 }
12875 arg2 = static_cast< double >(val2);
12876 if (arg1) (arg1)->hue = arg2;
12877
12878 resultobj = SWIG_Py_Void();
12879 return resultobj;
12880 fail:
12881 return NULL;
12882 }
12883
12884
12885 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12886 PyObject *resultobj = 0;
12887 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12888 double result;
12889 void *argp1 = 0 ;
12890 int res1 = 0 ;
12891 PyObject *swig_obj[1] ;
12892
12893 if (!args) SWIG_fail;
12894 swig_obj[0] = args;
12895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12896 if (!SWIG_IsOK(res1)) {
12897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12898 }
12899 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12900 result = (double) ((arg1)->hue);
12901 resultobj = SWIG_From_double(static_cast< double >(result));
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *resultobj = 0;
12910 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12911 double arg2 ;
12912 void *argp1 = 0 ;
12913 int res1 = 0 ;
12914 double val2 ;
12915 int ecode2 = 0 ;
12916 PyObject *swig_obj[2] ;
12917
12918 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12922 }
12923 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12924 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12925 if (!SWIG_IsOK(ecode2)) {
12926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12927 }
12928 arg2 = static_cast< double >(val2);
12929 if (arg1) (arg1)->saturation = arg2;
12930
12931 resultobj = SWIG_Py_Void();
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *resultobj = 0;
12940 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12941 double result;
12942 void *argp1 = 0 ;
12943 int res1 = 0 ;
12944 PyObject *swig_obj[1] ;
12945
12946 if (!args) SWIG_fail;
12947 swig_obj[0] = args;
12948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12951 }
12952 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12953 result = (double) ((arg1)->saturation);
12954 resultobj = SWIG_From_double(static_cast< double >(result));
12955 return resultobj;
12956 fail:
12957 return NULL;
12958 }
12959
12960
12961 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12962 PyObject *resultobj = 0;
12963 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12964 double arg2 ;
12965 void *argp1 = 0 ;
12966 int res1 = 0 ;
12967 double val2 ;
12968 int ecode2 = 0 ;
12969 PyObject *swig_obj[2] ;
12970
12971 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12973 if (!SWIG_IsOK(res1)) {
12974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12975 }
12976 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12977 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12978 if (!SWIG_IsOK(ecode2)) {
12979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12980 }
12981 arg2 = static_cast< double >(val2);
12982 if (arg1) (arg1)->value = arg2;
12983
12984 resultobj = SWIG_Py_Void();
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12992 PyObject *resultobj = 0;
12993 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12994 double result;
12995 void *argp1 = 0 ;
12996 int res1 = 0 ;
12997 PyObject *swig_obj[1] ;
12998
12999 if (!args) SWIG_fail;
13000 swig_obj[0] = args;
13001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13002 if (!SWIG_IsOK(res1)) {
13003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13004 }
13005 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13006 result = (double) ((arg1)->value);
13007 resultobj = SWIG_From_double(static_cast< double >(result));
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 PyObject *obj;
13016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13017 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13018 return SWIG_Py_Void();
13019 }
13020
13021 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13022 return SWIG_Python_InitShadowInstance(args);
13023 }
13024
13025 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13026 PyObject *resultobj = 0;
13027 wxString *arg1 = 0 ;
13028 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13029 int arg3 = (int) -1 ;
13030 wxImage *result = 0 ;
13031 bool temp1 = false ;
13032 long val2 ;
13033 int ecode2 = 0 ;
13034 int val3 ;
13035 int ecode3 = 0 ;
13036 PyObject * obj0 = 0 ;
13037 PyObject * obj1 = 0 ;
13038 PyObject * obj2 = 0 ;
13039 char * kwnames[] = {
13040 (char *) "name",(char *) "type",(char *) "index", NULL
13041 };
13042
13043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13044 {
13045 arg1 = wxString_in_helper(obj0);
13046 if (arg1 == NULL) SWIG_fail;
13047 temp1 = true;
13048 }
13049 if (obj1) {
13050 ecode2 = SWIG_AsVal_long(obj1, &val2);
13051 if (!SWIG_IsOK(ecode2)) {
13052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13053 }
13054 arg2 = static_cast< long >(val2);
13055 }
13056 if (obj2) {
13057 ecode3 = SWIG_AsVal_int(obj2, &val3);
13058 if (!SWIG_IsOK(ecode3)) {
13059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13060 }
13061 arg3 = static_cast< int >(val3);
13062 }
13063 {
13064 PyThreadState* __tstate = wxPyBeginAllowThreads();
13065 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13070 {
13071 if (temp1)
13072 delete arg1;
13073 }
13074 return resultobj;
13075 fail:
13076 {
13077 if (temp1)
13078 delete arg1;
13079 }
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 PyObject *resultobj = 0;
13086 wxImage *arg1 = (wxImage *) 0 ;
13087 void *argp1 = 0 ;
13088 int res1 = 0 ;
13089 PyObject *swig_obj[1] ;
13090
13091 if (!args) SWIG_fail;
13092 swig_obj[0] = args;
13093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13094 if (!SWIG_IsOK(res1)) {
13095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13096 }
13097 arg1 = reinterpret_cast< wxImage * >(argp1);
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 delete arg1;
13101
13102 wxPyEndAllowThreads(__tstate);
13103 if (PyErr_Occurred()) SWIG_fail;
13104 }
13105 resultobj = SWIG_Py_Void();
13106 return resultobj;
13107 fail:
13108 return NULL;
13109 }
13110
13111
13112 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13113 PyObject *resultobj = 0;
13114 wxString *arg1 = 0 ;
13115 wxString *arg2 = 0 ;
13116 int arg3 = (int) -1 ;
13117 wxImage *result = 0 ;
13118 bool temp1 = false ;
13119 bool temp2 = false ;
13120 int val3 ;
13121 int ecode3 = 0 ;
13122 PyObject * obj0 = 0 ;
13123 PyObject * obj1 = 0 ;
13124 PyObject * obj2 = 0 ;
13125 char * kwnames[] = {
13126 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13127 };
13128
13129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13130 {
13131 arg1 = wxString_in_helper(obj0);
13132 if (arg1 == NULL) SWIG_fail;
13133 temp1 = true;
13134 }
13135 {
13136 arg2 = wxString_in_helper(obj1);
13137 if (arg2 == NULL) SWIG_fail;
13138 temp2 = true;
13139 }
13140 if (obj2) {
13141 ecode3 = SWIG_AsVal_int(obj2, &val3);
13142 if (!SWIG_IsOK(ecode3)) {
13143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13144 }
13145 arg3 = static_cast< int >(val3);
13146 }
13147 {
13148 PyThreadState* __tstate = wxPyBeginAllowThreads();
13149 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13150 wxPyEndAllowThreads(__tstate);
13151 if (PyErr_Occurred()) SWIG_fail;
13152 }
13153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13154 {
13155 if (temp1)
13156 delete arg1;
13157 }
13158 {
13159 if (temp2)
13160 delete arg2;
13161 }
13162 return resultobj;
13163 fail:
13164 {
13165 if (temp1)
13166 delete arg1;
13167 }
13168 {
13169 if (temp2)
13170 delete arg2;
13171 }
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj = 0;
13178 wxInputStream *arg1 = 0 ;
13179 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13180 int arg3 = (int) -1 ;
13181 wxImage *result = 0 ;
13182 wxPyInputStream *temp1 ;
13183 bool created1 ;
13184 long val2 ;
13185 int ecode2 = 0 ;
13186 int val3 ;
13187 int ecode3 = 0 ;
13188 PyObject * obj0 = 0 ;
13189 PyObject * obj1 = 0 ;
13190 PyObject * obj2 = 0 ;
13191 char * kwnames[] = {
13192 (char *) "stream",(char *) "type",(char *) "index", NULL
13193 };
13194
13195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13196 {
13197 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13198 arg1 = temp1->m_wxis;
13199 created1 = false;
13200 } else {
13201 PyErr_Clear(); // clear the failure of the wxPyConvert above
13202 arg1 = wxPyCBInputStream_create(obj0, false);
13203 if (arg1 == NULL) {
13204 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13205 SWIG_fail;
13206 }
13207 created1 = true;
13208 }
13209 }
13210 if (obj1) {
13211 ecode2 = SWIG_AsVal_long(obj1, &val2);
13212 if (!SWIG_IsOK(ecode2)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13214 }
13215 arg2 = static_cast< long >(val2);
13216 }
13217 if (obj2) {
13218 ecode3 = SWIG_AsVal_int(obj2, &val3);
13219 if (!SWIG_IsOK(ecode3)) {
13220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13221 }
13222 arg3 = static_cast< int >(val3);
13223 }
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13231 {
13232 if (created1) delete arg1;
13233 }
13234 return resultobj;
13235 fail:
13236 {
13237 if (created1) delete arg1;
13238 }
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13244 PyObject *resultobj = 0;
13245 wxInputStream *arg1 = 0 ;
13246 wxString *arg2 = 0 ;
13247 int arg3 = (int) -1 ;
13248 wxImage *result = 0 ;
13249 wxPyInputStream *temp1 ;
13250 bool created1 ;
13251 bool temp2 = false ;
13252 int val3 ;
13253 int ecode3 = 0 ;
13254 PyObject * obj0 = 0 ;
13255 PyObject * obj1 = 0 ;
13256 PyObject * obj2 = 0 ;
13257 char * kwnames[] = {
13258 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13259 };
13260
13261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13262 {
13263 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13264 arg1 = temp1->m_wxis;
13265 created1 = false;
13266 } else {
13267 PyErr_Clear(); // clear the failure of the wxPyConvert above
13268 arg1 = wxPyCBInputStream_create(obj0, false);
13269 if (arg1 == NULL) {
13270 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13271 SWIG_fail;
13272 }
13273 created1 = true;
13274 }
13275 }
13276 {
13277 arg2 = wxString_in_helper(obj1);
13278 if (arg2 == NULL) SWIG_fail;
13279 temp2 = true;
13280 }
13281 if (obj2) {
13282 ecode3 = SWIG_AsVal_int(obj2, &val3);
13283 if (!SWIG_IsOK(ecode3)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13285 }
13286 arg3 = static_cast< int >(val3);
13287 }
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13295 {
13296 if (created1) delete arg1;
13297 }
13298 {
13299 if (temp2)
13300 delete arg2;
13301 }
13302 return resultobj;
13303 fail:
13304 {
13305 if (created1) delete arg1;
13306 }
13307 {
13308 if (temp2)
13309 delete arg2;
13310 }
13311 return NULL;
13312 }
13313
13314
13315 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13316 PyObject *resultobj = 0;
13317 int arg1 = (int) 0 ;
13318 int arg2 = (int) 0 ;
13319 bool arg3 = (bool) true ;
13320 wxImage *result = 0 ;
13321 int val1 ;
13322 int ecode1 = 0 ;
13323 int val2 ;
13324 int ecode2 = 0 ;
13325 bool val3 ;
13326 int ecode3 = 0 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 char * kwnames[] = {
13331 (char *) "width",(char *) "height",(char *) "clear", NULL
13332 };
13333
13334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13335 if (obj0) {
13336 ecode1 = SWIG_AsVal_int(obj0, &val1);
13337 if (!SWIG_IsOK(ecode1)) {
13338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13339 }
13340 arg1 = static_cast< int >(val1);
13341 }
13342 if (obj1) {
13343 ecode2 = SWIG_AsVal_int(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13346 }
13347 arg2 = static_cast< int >(val2);
13348 }
13349 if (obj2) {
13350 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13351 if (!SWIG_IsOK(ecode3)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13353 }
13354 arg3 = static_cast< bool >(val3);
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj = 0;
13371 wxBitmap *arg1 = 0 ;
13372 wxImage *result = 0 ;
13373 void *argp1 = 0 ;
13374 int res1 = 0 ;
13375 PyObject * obj0 = 0 ;
13376 char * kwnames[] = {
13377 (char *) "bitmap", NULL
13378 };
13379
13380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13381 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13382 if (!SWIG_IsOK(res1)) {
13383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13384 }
13385 if (!argp1) {
13386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13387 }
13388 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13389 {
13390 if (!wxPyCheckForApp()) SWIG_fail;
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13393 wxPyEndAllowThreads(__tstate);
13394 if (PyErr_Occurred()) SWIG_fail;
13395 }
13396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13397 return resultobj;
13398 fail:
13399 return NULL;
13400 }
13401
13402
13403 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13404 PyObject *resultobj = 0;
13405 int arg1 ;
13406 int arg2 ;
13407 buffer arg3 ;
13408 int arg4 ;
13409 wxImage *result = 0 ;
13410 int val1 ;
13411 int ecode1 = 0 ;
13412 int val2 ;
13413 int ecode2 = 0 ;
13414 PyObject * obj0 = 0 ;
13415 PyObject * obj1 = 0 ;
13416 PyObject * obj2 = 0 ;
13417 char * kwnames[] = {
13418 (char *) "width",(char *) "height",(char *) "data", NULL
13419 };
13420
13421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13422 ecode1 = SWIG_AsVal_int(obj0, &val1);
13423 if (!SWIG_IsOK(ecode1)) {
13424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13425 }
13426 arg1 = static_cast< int >(val1);
13427 ecode2 = SWIG_AsVal_int(obj1, &val2);
13428 if (!SWIG_IsOK(ecode2)) {
13429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13430 }
13431 arg2 = static_cast< int >(val2);
13432 {
13433 if (obj2 != Py_None) {
13434 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13435 }
13436 }
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj = 0;
13452 int arg1 ;
13453 int arg2 ;
13454 buffer arg3 ;
13455 int arg4 ;
13456 buffer arg5 ;
13457 int arg6 ;
13458 wxImage *result = 0 ;
13459 int val1 ;
13460 int ecode1 = 0 ;
13461 int val2 ;
13462 int ecode2 = 0 ;
13463 PyObject * obj0 = 0 ;
13464 PyObject * obj1 = 0 ;
13465 PyObject * obj2 = 0 ;
13466 PyObject * obj3 = 0 ;
13467 char * kwnames[] = {
13468 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13469 };
13470
13471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13472 ecode1 = SWIG_AsVal_int(obj0, &val1);
13473 if (!SWIG_IsOK(ecode1)) {
13474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13475 }
13476 arg1 = static_cast< int >(val1);
13477 ecode2 = SWIG_AsVal_int(obj1, &val2);
13478 if (!SWIG_IsOK(ecode2)) {
13479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13480 }
13481 arg2 = static_cast< int >(val2);
13482 {
13483 if (obj2 != Py_None) {
13484 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13485 }
13486 }
13487 {
13488 if (obj3 != Py_None) {
13489 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13490 }
13491 }
13492 {
13493 PyThreadState* __tstate = wxPyBeginAllowThreads();
13494 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13495 wxPyEndAllowThreads(__tstate);
13496 if (PyErr_Occurred()) SWIG_fail;
13497 }
13498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13499 return resultobj;
13500 fail:
13501 return NULL;
13502 }
13503
13504
13505 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13506 PyObject *resultobj = 0;
13507 wxImage *arg1 = (wxImage *) 0 ;
13508 int arg2 ;
13509 int arg3 ;
13510 bool arg4 = (bool) true ;
13511 void *argp1 = 0 ;
13512 int res1 = 0 ;
13513 int val2 ;
13514 int ecode2 = 0 ;
13515 int val3 ;
13516 int ecode3 = 0 ;
13517 bool val4 ;
13518 int ecode4 = 0 ;
13519 PyObject * obj0 = 0 ;
13520 PyObject * obj1 = 0 ;
13521 PyObject * obj2 = 0 ;
13522 PyObject * obj3 = 0 ;
13523 char * kwnames[] = {
13524 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13525 };
13526
13527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13529 if (!SWIG_IsOK(res1)) {
13530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13531 }
13532 arg1 = reinterpret_cast< wxImage * >(argp1);
13533 ecode2 = SWIG_AsVal_int(obj1, &val2);
13534 if (!SWIG_IsOK(ecode2)) {
13535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13536 }
13537 arg2 = static_cast< int >(val2);
13538 ecode3 = SWIG_AsVal_int(obj2, &val3);
13539 if (!SWIG_IsOK(ecode3)) {
13540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13541 }
13542 arg3 = static_cast< int >(val3);
13543 if (obj3) {
13544 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13545 if (!SWIG_IsOK(ecode4)) {
13546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13547 }
13548 arg4 = static_cast< bool >(val4);
13549 }
13550 {
13551 PyThreadState* __tstate = wxPyBeginAllowThreads();
13552 (arg1)->Create(arg2,arg3,arg4);
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 resultobj = SWIG_Py_Void();
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13564 PyObject *resultobj = 0;
13565 wxImage *arg1 = (wxImage *) 0 ;
13566 void *argp1 = 0 ;
13567 int res1 = 0 ;
13568 PyObject *swig_obj[1] ;
13569
13570 if (!args) SWIG_fail;
13571 swig_obj[0] = args;
13572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13575 }
13576 arg1 = reinterpret_cast< wxImage * >(argp1);
13577 {
13578 PyThreadState* __tstate = wxPyBeginAllowThreads();
13579 (arg1)->Destroy();
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 resultobj = SWIG_Py_Void();
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13591 PyObject *resultobj = 0;
13592 wxImage *arg1 = (wxImage *) 0 ;
13593 int arg2 ;
13594 int arg3 ;
13595 SwigValueWrapper<wxImage > result;
13596 void *argp1 = 0 ;
13597 int res1 = 0 ;
13598 int val2 ;
13599 int ecode2 = 0 ;
13600 int val3 ;
13601 int ecode3 = 0 ;
13602 PyObject * obj0 = 0 ;
13603 PyObject * obj1 = 0 ;
13604 PyObject * obj2 = 0 ;
13605 char * kwnames[] = {
13606 (char *) "self",(char *) "width",(char *) "height", NULL
13607 };
13608
13609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13611 if (!SWIG_IsOK(res1)) {
13612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13613 }
13614 arg1 = reinterpret_cast< wxImage * >(argp1);
13615 ecode2 = SWIG_AsVal_int(obj1, &val2);
13616 if (!SWIG_IsOK(ecode2)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13618 }
13619 arg2 = static_cast< int >(val2);
13620 ecode3 = SWIG_AsVal_int(obj2, &val3);
13621 if (!SWIG_IsOK(ecode3)) {
13622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13623 }
13624 arg3 = static_cast< int >(val3);
13625 {
13626 PyThreadState* __tstate = wxPyBeginAllowThreads();
13627 result = (arg1)->Scale(arg2,arg3);
13628 wxPyEndAllowThreads(__tstate);
13629 if (PyErr_Occurred()) SWIG_fail;
13630 }
13631 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13632 return resultobj;
13633 fail:
13634 return NULL;
13635 }
13636
13637
13638 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13639 PyObject *resultobj = 0;
13640 wxImage *arg1 = (wxImage *) 0 ;
13641 int arg2 ;
13642 int arg3 ;
13643 SwigValueWrapper<wxImage > result;
13644 void *argp1 = 0 ;
13645 int res1 = 0 ;
13646 int val2 ;
13647 int ecode2 = 0 ;
13648 int val3 ;
13649 int ecode3 = 0 ;
13650 PyObject * obj0 = 0 ;
13651 PyObject * obj1 = 0 ;
13652 PyObject * obj2 = 0 ;
13653 char * kwnames[] = {
13654 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13655 };
13656
13657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13659 if (!SWIG_IsOK(res1)) {
13660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13661 }
13662 arg1 = reinterpret_cast< wxImage * >(argp1);
13663 ecode2 = SWIG_AsVal_int(obj1, &val2);
13664 if (!SWIG_IsOK(ecode2)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13666 }
13667 arg2 = static_cast< int >(val2);
13668 ecode3 = SWIG_AsVal_int(obj2, &val3);
13669 if (!SWIG_IsOK(ecode3)) {
13670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13671 }
13672 arg3 = static_cast< int >(val3);
13673 {
13674 PyThreadState* __tstate = wxPyBeginAllowThreads();
13675 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13676 wxPyEndAllowThreads(__tstate);
13677 if (PyErr_Occurred()) SWIG_fail;
13678 }
13679 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13680 return resultobj;
13681 fail:
13682 return NULL;
13683 }
13684
13685
13686 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj = 0;
13688 wxImage *arg1 = (wxImage *) 0 ;
13689 int arg2 ;
13690 int arg3 ;
13691 wxImage *result = 0 ;
13692 void *argp1 = 0 ;
13693 int res1 = 0 ;
13694 int val2 ;
13695 int ecode2 = 0 ;
13696 int val3 ;
13697 int ecode3 = 0 ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 PyObject * obj2 = 0 ;
13701 char * kwnames[] = {
13702 (char *) "self",(char *) "width",(char *) "height", NULL
13703 };
13704
13705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13707 if (!SWIG_IsOK(res1)) {
13708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13709 }
13710 arg1 = reinterpret_cast< wxImage * >(argp1);
13711 ecode2 = SWIG_AsVal_int(obj1, &val2);
13712 if (!SWIG_IsOK(ecode2)) {
13713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13714 }
13715 arg2 = static_cast< int >(val2);
13716 ecode3 = SWIG_AsVal_int(obj2, &val3);
13717 if (!SWIG_IsOK(ecode3)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13719 }
13720 arg3 = static_cast< int >(val3);
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 {
13724 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13725 result = (wxImage *) &_result_ref;
13726 }
13727 wxPyEndAllowThreads(__tstate);
13728 if (PyErr_Occurred()) SWIG_fail;
13729 }
13730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13738 PyObject *resultobj = 0;
13739 wxImage *arg1 = (wxImage *) 0 ;
13740 wxSize *arg2 = 0 ;
13741 wxPoint *arg3 = 0 ;
13742 int arg4 = (int) -1 ;
13743 int arg5 = (int) -1 ;
13744 int arg6 = (int) -1 ;
13745 wxImage *result = 0 ;
13746 void *argp1 = 0 ;
13747 int res1 = 0 ;
13748 wxSize temp2 ;
13749 wxPoint temp3 ;
13750 int val4 ;
13751 int ecode4 = 0 ;
13752 int val5 ;
13753 int ecode5 = 0 ;
13754 int val6 ;
13755 int ecode6 = 0 ;
13756 PyObject * obj0 = 0 ;
13757 PyObject * obj1 = 0 ;
13758 PyObject * obj2 = 0 ;
13759 PyObject * obj3 = 0 ;
13760 PyObject * obj4 = 0 ;
13761 PyObject * obj5 = 0 ;
13762 char * kwnames[] = {
13763 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13764 };
13765
13766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13768 if (!SWIG_IsOK(res1)) {
13769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13770 }
13771 arg1 = reinterpret_cast< wxImage * >(argp1);
13772 {
13773 arg2 = &temp2;
13774 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13775 }
13776 {
13777 arg3 = &temp3;
13778 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13779 }
13780 if (obj3) {
13781 ecode4 = SWIG_AsVal_int(obj3, &val4);
13782 if (!SWIG_IsOK(ecode4)) {
13783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13784 }
13785 arg4 = static_cast< int >(val4);
13786 }
13787 if (obj4) {
13788 ecode5 = SWIG_AsVal_int(obj4, &val5);
13789 if (!SWIG_IsOK(ecode5)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13791 }
13792 arg5 = static_cast< int >(val5);
13793 }
13794 if (obj5) {
13795 ecode6 = SWIG_AsVal_int(obj5, &val6);
13796 if (!SWIG_IsOK(ecode6)) {
13797 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13798 }
13799 arg6 = static_cast< int >(val6);
13800 }
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 {
13804 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13805 result = (wxImage *) &_result_ref;
13806 }
13807 wxPyEndAllowThreads(__tstate);
13808 if (PyErr_Occurred()) SWIG_fail;
13809 }
13810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13811 return resultobj;
13812 fail:
13813 return NULL;
13814 }
13815
13816
13817 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13818 PyObject *resultobj = 0;
13819 wxImage *arg1 = (wxImage *) 0 ;
13820 int arg2 ;
13821 int arg3 ;
13822 byte arg4 ;
13823 byte arg5 ;
13824 byte arg6 ;
13825 void *argp1 = 0 ;
13826 int res1 = 0 ;
13827 int val2 ;
13828 int ecode2 = 0 ;
13829 int val3 ;
13830 int ecode3 = 0 ;
13831 unsigned char val4 ;
13832 int ecode4 = 0 ;
13833 unsigned char val5 ;
13834 int ecode5 = 0 ;
13835 unsigned char val6 ;
13836 int ecode6 = 0 ;
13837 PyObject * obj0 = 0 ;
13838 PyObject * obj1 = 0 ;
13839 PyObject * obj2 = 0 ;
13840 PyObject * obj3 = 0 ;
13841 PyObject * obj4 = 0 ;
13842 PyObject * obj5 = 0 ;
13843 char * kwnames[] = {
13844 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13845 };
13846
13847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13849 if (!SWIG_IsOK(res1)) {
13850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13851 }
13852 arg1 = reinterpret_cast< wxImage * >(argp1);
13853 ecode2 = SWIG_AsVal_int(obj1, &val2);
13854 if (!SWIG_IsOK(ecode2)) {
13855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13856 }
13857 arg2 = static_cast< int >(val2);
13858 ecode3 = SWIG_AsVal_int(obj2, &val3);
13859 if (!SWIG_IsOK(ecode3)) {
13860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13861 }
13862 arg3 = static_cast< int >(val3);
13863 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13864 if (!SWIG_IsOK(ecode4)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13866 }
13867 arg4 = static_cast< byte >(val4);
13868 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13869 if (!SWIG_IsOK(ecode5)) {
13870 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13871 }
13872 arg5 = static_cast< byte >(val5);
13873 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13874 if (!SWIG_IsOK(ecode6)) {
13875 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13876 }
13877 arg6 = static_cast< byte >(val6);
13878 {
13879 PyThreadState* __tstate = wxPyBeginAllowThreads();
13880 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13881 wxPyEndAllowThreads(__tstate);
13882 if (PyErr_Occurred()) SWIG_fail;
13883 }
13884 resultobj = SWIG_Py_Void();
13885 return resultobj;
13886 fail:
13887 return NULL;
13888 }
13889
13890
13891 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13892 PyObject *resultobj = 0;
13893 wxImage *arg1 = (wxImage *) 0 ;
13894 wxRect *arg2 = 0 ;
13895 byte arg3 ;
13896 byte arg4 ;
13897 byte arg5 ;
13898 void *argp1 = 0 ;
13899 int res1 = 0 ;
13900 wxRect temp2 ;
13901 unsigned char val3 ;
13902 int ecode3 = 0 ;
13903 unsigned char val4 ;
13904 int ecode4 = 0 ;
13905 unsigned char val5 ;
13906 int ecode5 = 0 ;
13907 PyObject * obj0 = 0 ;
13908 PyObject * obj1 = 0 ;
13909 PyObject * obj2 = 0 ;
13910 PyObject * obj3 = 0 ;
13911 PyObject * obj4 = 0 ;
13912 char * kwnames[] = {
13913 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13914 };
13915
13916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13918 if (!SWIG_IsOK(res1)) {
13919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13920 }
13921 arg1 = reinterpret_cast< wxImage * >(argp1);
13922 {
13923 arg2 = &temp2;
13924 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13925 }
13926 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13927 if (!SWIG_IsOK(ecode3)) {
13928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13929 }
13930 arg3 = static_cast< byte >(val3);
13931 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13932 if (!SWIG_IsOK(ecode4)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13934 }
13935 arg4 = static_cast< byte >(val4);
13936 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13937 if (!SWIG_IsOK(ecode5)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13939 }
13940 arg5 = static_cast< byte >(val5);
13941 {
13942 PyThreadState* __tstate = wxPyBeginAllowThreads();
13943 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13944 wxPyEndAllowThreads(__tstate);
13945 if (PyErr_Occurred()) SWIG_fail;
13946 }
13947 resultobj = SWIG_Py_Void();
13948 return resultobj;
13949 fail:
13950 return NULL;
13951 }
13952
13953
13954 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13955 PyObject *resultobj = 0;
13956 wxImage *arg1 = (wxImage *) 0 ;
13957 int arg2 ;
13958 int arg3 ;
13959 byte result;
13960 void *argp1 = 0 ;
13961 int res1 = 0 ;
13962 int val2 ;
13963 int ecode2 = 0 ;
13964 int val3 ;
13965 int ecode3 = 0 ;
13966 PyObject * obj0 = 0 ;
13967 PyObject * obj1 = 0 ;
13968 PyObject * obj2 = 0 ;
13969 char * kwnames[] = {
13970 (char *) "self",(char *) "x",(char *) "y", NULL
13971 };
13972
13973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13975 if (!SWIG_IsOK(res1)) {
13976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13977 }
13978 arg1 = reinterpret_cast< wxImage * >(argp1);
13979 ecode2 = SWIG_AsVal_int(obj1, &val2);
13980 if (!SWIG_IsOK(ecode2)) {
13981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13982 }
13983 arg2 = static_cast< int >(val2);
13984 ecode3 = SWIG_AsVal_int(obj2, &val3);
13985 if (!SWIG_IsOK(ecode3)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13987 }
13988 arg3 = static_cast< int >(val3);
13989 {
13990 PyThreadState* __tstate = wxPyBeginAllowThreads();
13991 result = (byte)(arg1)->GetRed(arg2,arg3);
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13996 return resultobj;
13997 fail:
13998 return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj = 0;
14004 wxImage *arg1 = (wxImage *) 0 ;
14005 int arg2 ;
14006 int arg3 ;
14007 byte result;
14008 void *argp1 = 0 ;
14009 int res1 = 0 ;
14010 int val2 ;
14011 int ecode2 = 0 ;
14012 int val3 ;
14013 int ecode3 = 0 ;
14014 PyObject * obj0 = 0 ;
14015 PyObject * obj1 = 0 ;
14016 PyObject * obj2 = 0 ;
14017 char * kwnames[] = {
14018 (char *) "self",(char *) "x",(char *) "y", NULL
14019 };
14020
14021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14023 if (!SWIG_IsOK(res1)) {
14024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14025 }
14026 arg1 = reinterpret_cast< wxImage * >(argp1);
14027 ecode2 = SWIG_AsVal_int(obj1, &val2);
14028 if (!SWIG_IsOK(ecode2)) {
14029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14030 }
14031 arg2 = static_cast< int >(val2);
14032 ecode3 = SWIG_AsVal_int(obj2, &val3);
14033 if (!SWIG_IsOK(ecode3)) {
14034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14035 }
14036 arg3 = static_cast< int >(val3);
14037 {
14038 PyThreadState* __tstate = wxPyBeginAllowThreads();
14039 result = (byte)(arg1)->GetGreen(arg2,arg3);
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14044 return resultobj;
14045 fail:
14046 return NULL;
14047 }
14048
14049
14050 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14051 PyObject *resultobj = 0;
14052 wxImage *arg1 = (wxImage *) 0 ;
14053 int arg2 ;
14054 int arg3 ;
14055 byte result;
14056 void *argp1 = 0 ;
14057 int res1 = 0 ;
14058 int val2 ;
14059 int ecode2 = 0 ;
14060 int val3 ;
14061 int ecode3 = 0 ;
14062 PyObject * obj0 = 0 ;
14063 PyObject * obj1 = 0 ;
14064 PyObject * obj2 = 0 ;
14065 char * kwnames[] = {
14066 (char *) "self",(char *) "x",(char *) "y", NULL
14067 };
14068
14069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14071 if (!SWIG_IsOK(res1)) {
14072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14073 }
14074 arg1 = reinterpret_cast< wxImage * >(argp1);
14075 ecode2 = SWIG_AsVal_int(obj1, &val2);
14076 if (!SWIG_IsOK(ecode2)) {
14077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14078 }
14079 arg2 = static_cast< int >(val2);
14080 ecode3 = SWIG_AsVal_int(obj2, &val3);
14081 if (!SWIG_IsOK(ecode3)) {
14082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14083 }
14084 arg3 = static_cast< int >(val3);
14085 {
14086 PyThreadState* __tstate = wxPyBeginAllowThreads();
14087 result = (byte)(arg1)->GetBlue(arg2,arg3);
14088 wxPyEndAllowThreads(__tstate);
14089 if (PyErr_Occurred()) SWIG_fail;
14090 }
14091 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14092 return resultobj;
14093 fail:
14094 return NULL;
14095 }
14096
14097
14098 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14099 PyObject *resultobj = 0;
14100 wxImage *arg1 = (wxImage *) 0 ;
14101 int arg2 ;
14102 int arg3 ;
14103 byte arg4 ;
14104 void *argp1 = 0 ;
14105 int res1 = 0 ;
14106 int val2 ;
14107 int ecode2 = 0 ;
14108 int val3 ;
14109 int ecode3 = 0 ;
14110 unsigned char val4 ;
14111 int ecode4 = 0 ;
14112 PyObject * obj0 = 0 ;
14113 PyObject * obj1 = 0 ;
14114 PyObject * obj2 = 0 ;
14115 PyObject * obj3 = 0 ;
14116 char * kwnames[] = {
14117 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14118 };
14119
14120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14122 if (!SWIG_IsOK(res1)) {
14123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14124 }
14125 arg1 = reinterpret_cast< wxImage * >(argp1);
14126 ecode2 = SWIG_AsVal_int(obj1, &val2);
14127 if (!SWIG_IsOK(ecode2)) {
14128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14129 }
14130 arg2 = static_cast< int >(val2);
14131 ecode3 = SWIG_AsVal_int(obj2, &val3);
14132 if (!SWIG_IsOK(ecode3)) {
14133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14134 }
14135 arg3 = static_cast< int >(val3);
14136 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14137 if (!SWIG_IsOK(ecode4)) {
14138 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14139 }
14140 arg4 = static_cast< byte >(val4);
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 (arg1)->SetAlpha(arg2,arg3,arg4);
14144 wxPyEndAllowThreads(__tstate);
14145 if (PyErr_Occurred()) SWIG_fail;
14146 }
14147 resultobj = SWIG_Py_Void();
14148 return resultobj;
14149 fail:
14150 return NULL;
14151 }
14152
14153
14154 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14155 PyObject *resultobj = 0;
14156 wxImage *arg1 = (wxImage *) 0 ;
14157 int arg2 ;
14158 int arg3 ;
14159 byte result;
14160 void *argp1 = 0 ;
14161 int res1 = 0 ;
14162 int val2 ;
14163 int ecode2 = 0 ;
14164 int val3 ;
14165 int ecode3 = 0 ;
14166 PyObject * obj0 = 0 ;
14167 PyObject * obj1 = 0 ;
14168 PyObject * obj2 = 0 ;
14169 char * kwnames[] = {
14170 (char *) "self",(char *) "x",(char *) "y", NULL
14171 };
14172
14173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14175 if (!SWIG_IsOK(res1)) {
14176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14177 }
14178 arg1 = reinterpret_cast< wxImage * >(argp1);
14179 ecode2 = SWIG_AsVal_int(obj1, &val2);
14180 if (!SWIG_IsOK(ecode2)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14182 }
14183 arg2 = static_cast< int >(val2);
14184 ecode3 = SWIG_AsVal_int(obj2, &val3);
14185 if (!SWIG_IsOK(ecode3)) {
14186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14187 }
14188 arg3 = static_cast< int >(val3);
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14203 PyObject *resultobj = 0;
14204 wxImage *arg1 = (wxImage *) 0 ;
14205 bool result;
14206 void *argp1 = 0 ;
14207 int res1 = 0 ;
14208 PyObject *swig_obj[1] ;
14209
14210 if (!args) SWIG_fail;
14211 swig_obj[0] = args;
14212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14213 if (!SWIG_IsOK(res1)) {
14214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14215 }
14216 arg1 = reinterpret_cast< wxImage * >(argp1);
14217 {
14218 PyThreadState* __tstate = wxPyBeginAllowThreads();
14219 result = (bool)(arg1)->HasAlpha();
14220 wxPyEndAllowThreads(__tstate);
14221 if (PyErr_Occurred()) SWIG_fail;
14222 }
14223 {
14224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14225 }
14226 return resultobj;
14227 fail:
14228 return NULL;
14229 }
14230
14231
14232 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14233 PyObject *resultobj = 0;
14234 wxImage *arg1 = (wxImage *) 0 ;
14235 void *argp1 = 0 ;
14236 int res1 = 0 ;
14237 PyObject *swig_obj[1] ;
14238
14239 if (!args) SWIG_fail;
14240 swig_obj[0] = args;
14241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14242 if (!SWIG_IsOK(res1)) {
14243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14244 }
14245 arg1 = reinterpret_cast< wxImage * >(argp1);
14246 {
14247 PyThreadState* __tstate = wxPyBeginAllowThreads();
14248 (arg1)->InitAlpha();
14249 wxPyEndAllowThreads(__tstate);
14250 if (PyErr_Occurred()) SWIG_fail;
14251 }
14252 resultobj = SWIG_Py_Void();
14253 return resultobj;
14254 fail:
14255 return NULL;
14256 }
14257
14258
14259 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj = 0;
14261 wxImage *arg1 = (wxImage *) 0 ;
14262 int arg2 ;
14263 int arg3 ;
14264 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14265 bool result;
14266 void *argp1 = 0 ;
14267 int res1 = 0 ;
14268 int val2 ;
14269 int ecode2 = 0 ;
14270 int val3 ;
14271 int ecode3 = 0 ;
14272 unsigned char val4 ;
14273 int ecode4 = 0 ;
14274 PyObject * obj0 = 0 ;
14275 PyObject * obj1 = 0 ;
14276 PyObject * obj2 = 0 ;
14277 PyObject * obj3 = 0 ;
14278 char * kwnames[] = {
14279 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14280 };
14281
14282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14284 if (!SWIG_IsOK(res1)) {
14285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14286 }
14287 arg1 = reinterpret_cast< wxImage * >(argp1);
14288 ecode2 = SWIG_AsVal_int(obj1, &val2);
14289 if (!SWIG_IsOK(ecode2)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14291 }
14292 arg2 = static_cast< int >(val2);
14293 ecode3 = SWIG_AsVal_int(obj2, &val3);
14294 if (!SWIG_IsOK(ecode3)) {
14295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14296 }
14297 arg3 = static_cast< int >(val3);
14298 if (obj3) {
14299 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14300 if (!SWIG_IsOK(ecode4)) {
14301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14302 }
14303 arg4 = static_cast< byte >(val4);
14304 }
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 {
14312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14313 }
14314 return resultobj;
14315 fail:
14316 return NULL;
14317 }
14318
14319
14320 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14321 PyObject *resultobj = 0;
14322 wxImage *arg1 = (wxImage *) 0 ;
14323 byte *arg2 = (byte *) 0 ;
14324 byte *arg3 = (byte *) 0 ;
14325 byte *arg4 = (byte *) 0 ;
14326 byte arg5 = (byte) 0 ;
14327 byte arg6 = (byte) 0 ;
14328 byte arg7 = (byte) 0 ;
14329 bool result;
14330 void *argp1 = 0 ;
14331 int res1 = 0 ;
14332 byte temp2 ;
14333 int res2 = SWIG_TMPOBJ ;
14334 byte temp3 ;
14335 int res3 = SWIG_TMPOBJ ;
14336 byte temp4 ;
14337 int res4 = SWIG_TMPOBJ ;
14338 unsigned char val5 ;
14339 int ecode5 = 0 ;
14340 unsigned char val6 ;
14341 int ecode6 = 0 ;
14342 unsigned char val7 ;
14343 int ecode7 = 0 ;
14344 PyObject * obj0 = 0 ;
14345 PyObject * obj1 = 0 ;
14346 PyObject * obj2 = 0 ;
14347 PyObject * obj3 = 0 ;
14348 char * kwnames[] = {
14349 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14350 };
14351
14352 arg2 = &temp2;
14353 arg3 = &temp3;
14354 arg4 = &temp4;
14355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14357 if (!SWIG_IsOK(res1)) {
14358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14359 }
14360 arg1 = reinterpret_cast< wxImage * >(argp1);
14361 if (obj1) {
14362 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14363 if (!SWIG_IsOK(ecode5)) {
14364 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14365 }
14366 arg5 = static_cast< byte >(val5);
14367 }
14368 if (obj2) {
14369 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14370 if (!SWIG_IsOK(ecode6)) {
14371 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14372 }
14373 arg6 = static_cast< byte >(val6);
14374 }
14375 if (obj3) {
14376 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14377 if (!SWIG_IsOK(ecode7)) {
14378 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14379 }
14380 arg7 = static_cast< byte >(val7);
14381 }
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 {
14389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14390 }
14391 if (SWIG_IsTmpObj(res2)) {
14392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14393 } else {
14394 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14396 }
14397 if (SWIG_IsTmpObj(res3)) {
14398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14399 } else {
14400 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14402 }
14403 if (SWIG_IsTmpObj(res4)) {
14404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14405 } else {
14406 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14408 }
14409 return resultobj;
14410 fail:
14411 return NULL;
14412 }
14413
14414
14415 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14416 PyObject *resultobj = 0;
14417 wxImage *arg1 = (wxImage *) 0 ;
14418 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14419 bool result;
14420 void *argp1 = 0 ;
14421 int res1 = 0 ;
14422 unsigned char val2 ;
14423 int ecode2 = 0 ;
14424 PyObject * obj0 = 0 ;
14425 PyObject * obj1 = 0 ;
14426 char * kwnames[] = {
14427 (char *) "self",(char *) "threshold", NULL
14428 };
14429
14430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14432 if (!SWIG_IsOK(res1)) {
14433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14434 }
14435 arg1 = reinterpret_cast< wxImage * >(argp1);
14436 if (obj1) {
14437 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14438 if (!SWIG_IsOK(ecode2)) {
14439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14440 }
14441 arg2 = static_cast< byte >(val2);
14442 }
14443 {
14444 PyThreadState* __tstate = wxPyBeginAllowThreads();
14445 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14446 wxPyEndAllowThreads(__tstate);
14447 if (PyErr_Occurred()) SWIG_fail;
14448 }
14449 {
14450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14451 }
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxImage *arg1 = (wxImage *) 0 ;
14461 byte arg2 ;
14462 byte arg3 ;
14463 byte arg4 ;
14464 bool result;
14465 void *argp1 = 0 ;
14466 int res1 = 0 ;
14467 unsigned char val2 ;
14468 int ecode2 = 0 ;
14469 unsigned char val3 ;
14470 int ecode3 = 0 ;
14471 unsigned char val4 ;
14472 int ecode4 = 0 ;
14473 PyObject * obj0 = 0 ;
14474 PyObject * obj1 = 0 ;
14475 PyObject * obj2 = 0 ;
14476 PyObject * obj3 = 0 ;
14477 char * kwnames[] = {
14478 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14479 };
14480
14481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14483 if (!SWIG_IsOK(res1)) {
14484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14485 }
14486 arg1 = reinterpret_cast< wxImage * >(argp1);
14487 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14488 if (!SWIG_IsOK(ecode2)) {
14489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14490 }
14491 arg2 = static_cast< byte >(val2);
14492 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14493 if (!SWIG_IsOK(ecode3)) {
14494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14495 }
14496 arg3 = static_cast< byte >(val3);
14497 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14498 if (!SWIG_IsOK(ecode4)) {
14499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14500 }
14501 arg4 = static_cast< byte >(val4);
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxImage *arg1 = (wxImage *) 0 ;
14520 wxImage *arg2 = 0 ;
14521 byte arg3 ;
14522 byte arg4 ;
14523 byte arg5 ;
14524 bool result;
14525 void *argp1 = 0 ;
14526 int res1 = 0 ;
14527 void *argp2 = 0 ;
14528 int res2 = 0 ;
14529 unsigned char val3 ;
14530 int ecode3 = 0 ;
14531 unsigned char val4 ;
14532 int ecode4 = 0 ;
14533 unsigned char val5 ;
14534 int ecode5 = 0 ;
14535 PyObject * obj0 = 0 ;
14536 PyObject * obj1 = 0 ;
14537 PyObject * obj2 = 0 ;
14538 PyObject * obj3 = 0 ;
14539 PyObject * obj4 = 0 ;
14540 char * kwnames[] = {
14541 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14542 };
14543
14544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14546 if (!SWIG_IsOK(res1)) {
14547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14548 }
14549 arg1 = reinterpret_cast< wxImage * >(argp1);
14550 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14551 if (!SWIG_IsOK(res2)) {
14552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14553 }
14554 if (!argp2) {
14555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14556 }
14557 arg2 = reinterpret_cast< wxImage * >(argp2);
14558 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14559 if (!SWIG_IsOK(ecode3)) {
14560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14561 }
14562 arg3 = static_cast< byte >(val3);
14563 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14564 if (!SWIG_IsOK(ecode4)) {
14565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14566 }
14567 arg4 = static_cast< byte >(val4);
14568 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14569 if (!SWIG_IsOK(ecode5)) {
14570 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14571 }
14572 arg5 = static_cast< byte >(val5);
14573 {
14574 PyThreadState* __tstate = wxPyBeginAllowThreads();
14575 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 {
14580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14581 }
14582 return resultobj;
14583 fail:
14584 return NULL;
14585 }
14586
14587
14588 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14589 PyObject *resultobj = 0;
14590 wxString *arg1 = 0 ;
14591 bool result;
14592 bool temp1 = false ;
14593 PyObject * obj0 = 0 ;
14594 char * kwnames[] = {
14595 (char *) "filename", NULL
14596 };
14597
14598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14599 {
14600 arg1 = wxString_in_helper(obj0);
14601 if (arg1 == NULL) SWIG_fail;
14602 temp1 = true;
14603 }
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 {
14611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14612 }
14613 {
14614 if (temp1)
14615 delete arg1;
14616 }
14617 return resultobj;
14618 fail:
14619 {
14620 if (temp1)
14621 delete arg1;
14622 }
14623 return NULL;
14624 }
14625
14626
14627 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14628 PyObject *resultobj = 0;
14629 wxString *arg1 = 0 ;
14630 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14631 int result;
14632 bool temp1 = false ;
14633 long val2 ;
14634 int ecode2 = 0 ;
14635 PyObject * obj0 = 0 ;
14636 PyObject * obj1 = 0 ;
14637 char * kwnames[] = {
14638 (char *) "filename",(char *) "type", NULL
14639 };
14640
14641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14642 {
14643 arg1 = wxString_in_helper(obj0);
14644 if (arg1 == NULL) SWIG_fail;
14645 temp1 = true;
14646 }
14647 if (obj1) {
14648 ecode2 = SWIG_AsVal_long(obj1, &val2);
14649 if (!SWIG_IsOK(ecode2)) {
14650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14651 }
14652 arg2 = static_cast< long >(val2);
14653 }
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14657 wxPyEndAllowThreads(__tstate);
14658 if (PyErr_Occurred()) SWIG_fail;
14659 }
14660 resultobj = SWIG_From_int(static_cast< int >(result));
14661 {
14662 if (temp1)
14663 delete arg1;
14664 }
14665 return resultobj;
14666 fail:
14667 {
14668 if (temp1)
14669 delete arg1;
14670 }
14671 return NULL;
14672 }
14673
14674
14675 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14676 PyObject *resultobj = 0;
14677 wxImage *arg1 = (wxImage *) 0 ;
14678 wxString *arg2 = 0 ;
14679 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14680 int arg4 = (int) -1 ;
14681 bool result;
14682 void *argp1 = 0 ;
14683 int res1 = 0 ;
14684 bool temp2 = false ;
14685 long val3 ;
14686 int ecode3 = 0 ;
14687 int val4 ;
14688 int ecode4 = 0 ;
14689 PyObject * obj0 = 0 ;
14690 PyObject * obj1 = 0 ;
14691 PyObject * obj2 = 0 ;
14692 PyObject * obj3 = 0 ;
14693 char * kwnames[] = {
14694 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14695 };
14696
14697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14699 if (!SWIG_IsOK(res1)) {
14700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14701 }
14702 arg1 = reinterpret_cast< wxImage * >(argp1);
14703 {
14704 arg2 = wxString_in_helper(obj1);
14705 if (arg2 == NULL) SWIG_fail;
14706 temp2 = true;
14707 }
14708 if (obj2) {
14709 ecode3 = SWIG_AsVal_long(obj2, &val3);
14710 if (!SWIG_IsOK(ecode3)) {
14711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14712 }
14713 arg3 = static_cast< long >(val3);
14714 }
14715 if (obj3) {
14716 ecode4 = SWIG_AsVal_int(obj3, &val4);
14717 if (!SWIG_IsOK(ecode4)) {
14718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14719 }
14720 arg4 = static_cast< int >(val4);
14721 }
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 {
14729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14730 }
14731 {
14732 if (temp2)
14733 delete arg2;
14734 }
14735 return resultobj;
14736 fail:
14737 {
14738 if (temp2)
14739 delete arg2;
14740 }
14741 return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14746 PyObject *resultobj = 0;
14747 wxImage *arg1 = (wxImage *) 0 ;
14748 wxString *arg2 = 0 ;
14749 wxString *arg3 = 0 ;
14750 int arg4 = (int) -1 ;
14751 bool result;
14752 void *argp1 = 0 ;
14753 int res1 = 0 ;
14754 bool temp2 = false ;
14755 bool temp3 = false ;
14756 int val4 ;
14757 int ecode4 = 0 ;
14758 PyObject * obj0 = 0 ;
14759 PyObject * obj1 = 0 ;
14760 PyObject * obj2 = 0 ;
14761 PyObject * obj3 = 0 ;
14762 char * kwnames[] = {
14763 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14764 };
14765
14766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14768 if (!SWIG_IsOK(res1)) {
14769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14770 }
14771 arg1 = reinterpret_cast< wxImage * >(argp1);
14772 {
14773 arg2 = wxString_in_helper(obj1);
14774 if (arg2 == NULL) SWIG_fail;
14775 temp2 = true;
14776 }
14777 {
14778 arg3 = wxString_in_helper(obj2);
14779 if (arg3 == NULL) SWIG_fail;
14780 temp3 = true;
14781 }
14782 if (obj3) {
14783 ecode4 = SWIG_AsVal_int(obj3, &val4);
14784 if (!SWIG_IsOK(ecode4)) {
14785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14786 }
14787 arg4 = static_cast< int >(val4);
14788 }
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 {
14799 if (temp2)
14800 delete arg2;
14801 }
14802 {
14803 if (temp3)
14804 delete arg3;
14805 }
14806 return resultobj;
14807 fail:
14808 {
14809 if (temp2)
14810 delete arg2;
14811 }
14812 {
14813 if (temp3)
14814 delete arg3;
14815 }
14816 return NULL;
14817 }
14818
14819
14820 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14821 PyObject *resultobj = 0;
14822 wxImage *arg1 = (wxImage *) 0 ;
14823 wxString *arg2 = 0 ;
14824 int arg3 ;
14825 bool result;
14826 void *argp1 = 0 ;
14827 int res1 = 0 ;
14828 bool temp2 = false ;
14829 int val3 ;
14830 int ecode3 = 0 ;
14831 PyObject * obj0 = 0 ;
14832 PyObject * obj1 = 0 ;
14833 PyObject * obj2 = 0 ;
14834 char * kwnames[] = {
14835 (char *) "self",(char *) "name",(char *) "type", NULL
14836 };
14837
14838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14840 if (!SWIG_IsOK(res1)) {
14841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14842 }
14843 arg1 = reinterpret_cast< wxImage * >(argp1);
14844 {
14845 arg2 = wxString_in_helper(obj1);
14846 if (arg2 == NULL) SWIG_fail;
14847 temp2 = true;
14848 }
14849 ecode3 = SWIG_AsVal_int(obj2, &val3);
14850 if (!SWIG_IsOK(ecode3)) {
14851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14852 }
14853 arg3 = static_cast< int >(val3);
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 {
14861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14862 }
14863 {
14864 if (temp2)
14865 delete arg2;
14866 }
14867 return resultobj;
14868 fail:
14869 {
14870 if (temp2)
14871 delete arg2;
14872 }
14873 return NULL;
14874 }
14875
14876
14877 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14878 PyObject *resultobj = 0;
14879 wxImage *arg1 = (wxImage *) 0 ;
14880 wxString *arg2 = 0 ;
14881 wxString *arg3 = 0 ;
14882 bool result;
14883 void *argp1 = 0 ;
14884 int res1 = 0 ;
14885 bool temp2 = false ;
14886 bool temp3 = false ;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 PyObject * obj2 = 0 ;
14890 char * kwnames[] = {
14891 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14892 };
14893
14894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14896 if (!SWIG_IsOK(res1)) {
14897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14898 }
14899 arg1 = reinterpret_cast< wxImage * >(argp1);
14900 {
14901 arg2 = wxString_in_helper(obj1);
14902 if (arg2 == NULL) SWIG_fail;
14903 temp2 = true;
14904 }
14905 {
14906 arg3 = wxString_in_helper(obj2);
14907 if (arg3 == NULL) SWIG_fail;
14908 temp3 = true;
14909 }
14910 {
14911 PyThreadState* __tstate = wxPyBeginAllowThreads();
14912 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14913 wxPyEndAllowThreads(__tstate);
14914 if (PyErr_Occurred()) SWIG_fail;
14915 }
14916 {
14917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14918 }
14919 {
14920 if (temp2)
14921 delete arg2;
14922 }
14923 {
14924 if (temp3)
14925 delete arg3;
14926 }
14927 return resultobj;
14928 fail:
14929 {
14930 if (temp2)
14931 delete arg2;
14932 }
14933 {
14934 if (temp3)
14935 delete arg3;
14936 }
14937 return NULL;
14938 }
14939
14940
14941 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14942 PyObject *resultobj = 0;
14943 wxInputStream *arg1 = 0 ;
14944 bool result;
14945 wxPyInputStream *temp1 ;
14946 bool created1 ;
14947 PyObject * obj0 = 0 ;
14948 char * kwnames[] = {
14949 (char *) "stream", NULL
14950 };
14951
14952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14953 {
14954 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14955 arg1 = temp1->m_wxis;
14956 created1 = false;
14957 } else {
14958 PyErr_Clear(); // clear the failure of the wxPyConvert above
14959 arg1 = wxPyCBInputStream_create(obj0, false);
14960 if (arg1 == NULL) {
14961 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14962 SWIG_fail;
14963 }
14964 created1 = true;
14965 }
14966 }
14967 {
14968 PyThreadState* __tstate = wxPyBeginAllowThreads();
14969 result = (bool)wxImage::CanRead(*arg1);
14970 wxPyEndAllowThreads(__tstate);
14971 if (PyErr_Occurred()) SWIG_fail;
14972 }
14973 {
14974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14975 }
14976 {
14977 if (created1) delete arg1;
14978 }
14979 return resultobj;
14980 fail:
14981 {
14982 if (created1) delete arg1;
14983 }
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj = 0;
14990 wxImage *arg1 = (wxImage *) 0 ;
14991 wxInputStream *arg2 = 0 ;
14992 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14993 int arg4 = (int) -1 ;
14994 bool result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 wxPyInputStream *temp2 ;
14998 bool created2 ;
14999 long val3 ;
15000 int ecode3 = 0 ;
15001 int val4 ;
15002 int ecode4 = 0 ;
15003 PyObject * obj0 = 0 ;
15004 PyObject * obj1 = 0 ;
15005 PyObject * obj2 = 0 ;
15006 PyObject * obj3 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15015 }
15016 arg1 = reinterpret_cast< wxImage * >(argp1);
15017 {
15018 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15019 arg2 = temp2->m_wxis;
15020 created2 = false;
15021 } else {
15022 PyErr_Clear(); // clear the failure of the wxPyConvert above
15023 arg2 = wxPyCBInputStream_create(obj1, false);
15024 if (arg2 == NULL) {
15025 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15026 SWIG_fail;
15027 }
15028 created2 = true;
15029 }
15030 }
15031 if (obj2) {
15032 ecode3 = SWIG_AsVal_long(obj2, &val3);
15033 if (!SWIG_IsOK(ecode3)) {
15034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15035 }
15036 arg3 = static_cast< long >(val3);
15037 }
15038 if (obj3) {
15039 ecode4 = SWIG_AsVal_int(obj3, &val4);
15040 if (!SWIG_IsOK(ecode4)) {
15041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15042 }
15043 arg4 = static_cast< int >(val4);
15044 }
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 {
15052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15053 }
15054 {
15055 if (created2) delete arg2;
15056 }
15057 return resultobj;
15058 fail:
15059 {
15060 if (created2) delete arg2;
15061 }
15062 return NULL;
15063 }
15064
15065
15066 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj = 0;
15068 wxImage *arg1 = (wxImage *) 0 ;
15069 wxInputStream *arg2 = 0 ;
15070 wxString *arg3 = 0 ;
15071 int arg4 = (int) -1 ;
15072 bool result;
15073 void *argp1 = 0 ;
15074 int res1 = 0 ;
15075 wxPyInputStream *temp2 ;
15076 bool created2 ;
15077 bool temp3 = false ;
15078 int val4 ;
15079 int ecode4 = 0 ;
15080 PyObject * obj0 = 0 ;
15081 PyObject * obj1 = 0 ;
15082 PyObject * obj2 = 0 ;
15083 PyObject * obj3 = 0 ;
15084 char * kwnames[] = {
15085 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15086 };
15087
15088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15090 if (!SWIG_IsOK(res1)) {
15091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15092 }
15093 arg1 = reinterpret_cast< wxImage * >(argp1);
15094 {
15095 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15096 arg2 = temp2->m_wxis;
15097 created2 = false;
15098 } else {
15099 PyErr_Clear(); // clear the failure of the wxPyConvert above
15100 arg2 = wxPyCBInputStream_create(obj1, false);
15101 if (arg2 == NULL) {
15102 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15103 SWIG_fail;
15104 }
15105 created2 = true;
15106 }
15107 }
15108 {
15109 arg3 = wxString_in_helper(obj2);
15110 if (arg3 == NULL) SWIG_fail;
15111 temp3 = true;
15112 }
15113 if (obj3) {
15114 ecode4 = SWIG_AsVal_int(obj3, &val4);
15115 if (!SWIG_IsOK(ecode4)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15117 }
15118 arg4 = static_cast< int >(val4);
15119 }
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 {
15127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15128 }
15129 {
15130 if (created2) delete arg2;
15131 }
15132 {
15133 if (temp3)
15134 delete arg3;
15135 }
15136 return resultobj;
15137 fail:
15138 {
15139 if (created2) delete arg2;
15140 }
15141 {
15142 if (temp3)
15143 delete arg3;
15144 }
15145 return NULL;
15146 }
15147
15148
15149 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15150 PyObject *resultobj = 0;
15151 wxImage *arg1 = (wxImage *) 0 ;
15152 bool result;
15153 void *argp1 = 0 ;
15154 int res1 = 0 ;
15155 PyObject *swig_obj[1] ;
15156
15157 if (!args) SWIG_fail;
15158 swig_obj[0] = args;
15159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15160 if (!SWIG_IsOK(res1)) {
15161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15162 }
15163 arg1 = reinterpret_cast< wxImage * >(argp1);
15164 {
15165 PyThreadState* __tstate = wxPyBeginAllowThreads();
15166 result = (bool)(arg1)->Ok();
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 {
15171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15172 }
15173 return resultobj;
15174 fail:
15175 return NULL;
15176 }
15177
15178
15179 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15180 PyObject *resultobj = 0;
15181 wxImage *arg1 = (wxImage *) 0 ;
15182 int result;
15183 void *argp1 = 0 ;
15184 int res1 = 0 ;
15185 PyObject *swig_obj[1] ;
15186
15187 if (!args) SWIG_fail;
15188 swig_obj[0] = args;
15189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15190 if (!SWIG_IsOK(res1)) {
15191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15192 }
15193 arg1 = reinterpret_cast< wxImage * >(argp1);
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 result = (int)(arg1)->GetWidth();
15197 wxPyEndAllowThreads(__tstate);
15198 if (PyErr_Occurred()) SWIG_fail;
15199 }
15200 resultobj = SWIG_From_int(static_cast< int >(result));
15201 return resultobj;
15202 fail:
15203 return NULL;
15204 }
15205
15206
15207 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15208 PyObject *resultobj = 0;
15209 wxImage *arg1 = (wxImage *) 0 ;
15210 int result;
15211 void *argp1 = 0 ;
15212 int res1 = 0 ;
15213 PyObject *swig_obj[1] ;
15214
15215 if (!args) SWIG_fail;
15216 swig_obj[0] = args;
15217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15218 if (!SWIG_IsOK(res1)) {
15219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15220 }
15221 arg1 = reinterpret_cast< wxImage * >(argp1);
15222 {
15223 PyThreadState* __tstate = wxPyBeginAllowThreads();
15224 result = (int)(arg1)->GetHeight();
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 resultobj = SWIG_From_int(static_cast< int >(result));
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15236 PyObject *resultobj = 0;
15237 wxImage *arg1 = (wxImage *) 0 ;
15238 wxSize result;
15239 void *argp1 = 0 ;
15240 int res1 = 0 ;
15241 PyObject *swig_obj[1] ;
15242
15243 if (!args) SWIG_fail;
15244 swig_obj[0] = args;
15245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15246 if (!SWIG_IsOK(res1)) {
15247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15248 }
15249 arg1 = reinterpret_cast< wxImage * >(argp1);
15250 {
15251 PyThreadState* __tstate = wxPyBeginAllowThreads();
15252 result = wxImage_GetSize(arg1);
15253 wxPyEndAllowThreads(__tstate);
15254 if (PyErr_Occurred()) SWIG_fail;
15255 }
15256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15264 PyObject *resultobj = 0;
15265 wxImage *arg1 = (wxImage *) 0 ;
15266 wxRect *arg2 = 0 ;
15267 SwigValueWrapper<wxImage > result;
15268 void *argp1 = 0 ;
15269 int res1 = 0 ;
15270 wxRect temp2 ;
15271 PyObject * obj0 = 0 ;
15272 PyObject * obj1 = 0 ;
15273 char * kwnames[] = {
15274 (char *) "self",(char *) "rect", NULL
15275 };
15276
15277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15279 if (!SWIG_IsOK(res1)) {
15280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15281 }
15282 arg1 = reinterpret_cast< wxImage * >(argp1);
15283 {
15284 arg2 = &temp2;
15285 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15301 PyObject *resultobj = 0;
15302 wxImage *arg1 = (wxImage *) 0 ;
15303 wxSize *arg2 = 0 ;
15304 wxPoint *arg3 = 0 ;
15305 int arg4 = (int) -1 ;
15306 int arg5 = (int) -1 ;
15307 int arg6 = (int) -1 ;
15308 SwigValueWrapper<wxImage > result;
15309 void *argp1 = 0 ;
15310 int res1 = 0 ;
15311 wxSize temp2 ;
15312 wxPoint temp3 ;
15313 int val4 ;
15314 int ecode4 = 0 ;
15315 int val5 ;
15316 int ecode5 = 0 ;
15317 int val6 ;
15318 int ecode6 = 0 ;
15319 PyObject * obj0 = 0 ;
15320 PyObject * obj1 = 0 ;
15321 PyObject * obj2 = 0 ;
15322 PyObject * obj3 = 0 ;
15323 PyObject * obj4 = 0 ;
15324 PyObject * obj5 = 0 ;
15325 char * kwnames[] = {
15326 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15327 };
15328
15329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15331 if (!SWIG_IsOK(res1)) {
15332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15333 }
15334 arg1 = reinterpret_cast< wxImage * >(argp1);
15335 {
15336 arg2 = &temp2;
15337 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15338 }
15339 {
15340 arg3 = &temp3;
15341 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15342 }
15343 if (obj3) {
15344 ecode4 = SWIG_AsVal_int(obj3, &val4);
15345 if (!SWIG_IsOK(ecode4)) {
15346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15347 }
15348 arg4 = static_cast< int >(val4);
15349 }
15350 if (obj4) {
15351 ecode5 = SWIG_AsVal_int(obj4, &val5);
15352 if (!SWIG_IsOK(ecode5)) {
15353 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15354 }
15355 arg5 = static_cast< int >(val5);
15356 }
15357 if (obj5) {
15358 ecode6 = SWIG_AsVal_int(obj5, &val6);
15359 if (!SWIG_IsOK(ecode6)) {
15360 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15361 }
15362 arg6 = static_cast< int >(val6);
15363 }
15364 {
15365 PyThreadState* __tstate = wxPyBeginAllowThreads();
15366 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15367 wxPyEndAllowThreads(__tstate);
15368 if (PyErr_Occurred()) SWIG_fail;
15369 }
15370 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15371 return resultobj;
15372 fail:
15373 return NULL;
15374 }
15375
15376
15377 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15378 PyObject *resultobj = 0;
15379 wxImage *arg1 = (wxImage *) 0 ;
15380 SwigValueWrapper<wxImage > result;
15381 void *argp1 = 0 ;
15382 int res1 = 0 ;
15383 PyObject *swig_obj[1] ;
15384
15385 if (!args) SWIG_fail;
15386 swig_obj[0] = args;
15387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15388 if (!SWIG_IsOK(res1)) {
15389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15390 }
15391 arg1 = reinterpret_cast< wxImage * >(argp1);
15392 {
15393 PyThreadState* __tstate = wxPyBeginAllowThreads();
15394 result = (arg1)->Copy();
15395 wxPyEndAllowThreads(__tstate);
15396 if (PyErr_Occurred()) SWIG_fail;
15397 }
15398 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15399 return resultobj;
15400 fail:
15401 return NULL;
15402 }
15403
15404
15405 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15406 PyObject *resultobj = 0;
15407 wxImage *arg1 = (wxImage *) 0 ;
15408 wxImage *arg2 = 0 ;
15409 int arg3 ;
15410 int arg4 ;
15411 void *argp1 = 0 ;
15412 int res1 = 0 ;
15413 void *argp2 = 0 ;
15414 int res2 = 0 ;
15415 int val3 ;
15416 int ecode3 = 0 ;
15417 int val4 ;
15418 int ecode4 = 0 ;
15419 PyObject * obj0 = 0 ;
15420 PyObject * obj1 = 0 ;
15421 PyObject * obj2 = 0 ;
15422 PyObject * obj3 = 0 ;
15423 char * kwnames[] = {
15424 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15425 };
15426
15427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15429 if (!SWIG_IsOK(res1)) {
15430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15431 }
15432 arg1 = reinterpret_cast< wxImage * >(argp1);
15433 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15434 if (!SWIG_IsOK(res2)) {
15435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15436 }
15437 if (!argp2) {
15438 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15439 }
15440 arg2 = reinterpret_cast< wxImage * >(argp2);
15441 ecode3 = SWIG_AsVal_int(obj2, &val3);
15442 if (!SWIG_IsOK(ecode3)) {
15443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15444 }
15445 arg3 = static_cast< int >(val3);
15446 ecode4 = SWIG_AsVal_int(obj3, &val4);
15447 if (!SWIG_IsOK(ecode4)) {
15448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15449 }
15450 arg4 = static_cast< int >(val4);
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15454 wxPyEndAllowThreads(__tstate);
15455 if (PyErr_Occurred()) SWIG_fail;
15456 }
15457 resultobj = SWIG_Py_Void();
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15465 PyObject *resultobj = 0;
15466 wxImage *arg1 = (wxImage *) 0 ;
15467 PyObject *result = 0 ;
15468 void *argp1 = 0 ;
15469 int res1 = 0 ;
15470 PyObject *swig_obj[1] ;
15471
15472 if (!args) SWIG_fail;
15473 swig_obj[0] = args;
15474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15475 if (!SWIG_IsOK(res1)) {
15476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15477 }
15478 arg1 = reinterpret_cast< wxImage * >(argp1);
15479 {
15480 PyThreadState* __tstate = wxPyBeginAllowThreads();
15481 result = (PyObject *)wxImage_GetData(arg1);
15482 wxPyEndAllowThreads(__tstate);
15483 if (PyErr_Occurred()) SWIG_fail;
15484 }
15485 resultobj = result;
15486 return resultobj;
15487 fail:
15488 return NULL;
15489 }
15490
15491
15492 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15493 PyObject *resultobj = 0;
15494 wxImage *arg1 = (wxImage *) 0 ;
15495 buffer arg2 ;
15496 int arg3 ;
15497 void *argp1 = 0 ;
15498 int res1 = 0 ;
15499 PyObject * obj0 = 0 ;
15500 PyObject * obj1 = 0 ;
15501 char * kwnames[] = {
15502 (char *) "self",(char *) "data", NULL
15503 };
15504
15505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15509 }
15510 arg1 = reinterpret_cast< wxImage * >(argp1);
15511 {
15512 if (obj1 != Py_None) {
15513 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15514 }
15515 }
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 wxImage_SetData(arg1,arg2,arg3);
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 resultobj = SWIG_Py_Void();
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15530 PyObject *resultobj = 0;
15531 wxImage *arg1 = (wxImage *) 0 ;
15532 PyObject *result = 0 ;
15533 void *argp1 = 0 ;
15534 int res1 = 0 ;
15535 PyObject *swig_obj[1] ;
15536
15537 if (!args) SWIG_fail;
15538 swig_obj[0] = args;
15539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15540 if (!SWIG_IsOK(res1)) {
15541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15542 }
15543 arg1 = reinterpret_cast< wxImage * >(argp1);
15544 {
15545 PyThreadState* __tstate = wxPyBeginAllowThreads();
15546 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 resultobj = result;
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj = 0;
15559 wxImage *arg1 = (wxImage *) 0 ;
15560 buffer arg2 ;
15561 int arg3 ;
15562 void *argp1 = 0 ;
15563 int res1 = 0 ;
15564 PyObject * obj0 = 0 ;
15565 PyObject * obj1 = 0 ;
15566 char * kwnames[] = {
15567 (char *) "self",(char *) "data", NULL
15568 };
15569
15570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15572 if (!SWIG_IsOK(res1)) {
15573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15574 }
15575 arg1 = reinterpret_cast< wxImage * >(argp1);
15576 {
15577 if (obj1 != Py_None) {
15578 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15579 }
15580 }
15581 {
15582 PyThreadState* __tstate = wxPyBeginAllowThreads();
15583 wxImage_SetDataBuffer(arg1,arg2,arg3);
15584 wxPyEndAllowThreads(__tstate);
15585 if (PyErr_Occurred()) SWIG_fail;
15586 }
15587 resultobj = SWIG_Py_Void();
15588 return resultobj;
15589 fail:
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15595 PyObject *resultobj = 0;
15596 wxImage *arg1 = (wxImage *) 0 ;
15597 PyObject *result = 0 ;
15598 void *argp1 = 0 ;
15599 int res1 = 0 ;
15600 PyObject *swig_obj[1] ;
15601
15602 if (!args) SWIG_fail;
15603 swig_obj[0] = args;
15604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15605 if (!SWIG_IsOK(res1)) {
15606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15607 }
15608 arg1 = reinterpret_cast< wxImage * >(argp1);
15609 {
15610 PyThreadState* __tstate = wxPyBeginAllowThreads();
15611 result = (PyObject *)wxImage_GetAlphaData(arg1);
15612 wxPyEndAllowThreads(__tstate);
15613 if (PyErr_Occurred()) SWIG_fail;
15614 }
15615 resultobj = result;
15616 return resultobj;
15617 fail:
15618 return NULL;
15619 }
15620
15621
15622 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15623 PyObject *resultobj = 0;
15624 wxImage *arg1 = (wxImage *) 0 ;
15625 buffer arg2 ;
15626 int arg3 ;
15627 void *argp1 = 0 ;
15628 int res1 = 0 ;
15629 PyObject * obj0 = 0 ;
15630 PyObject * obj1 = 0 ;
15631 char * kwnames[] = {
15632 (char *) "self",(char *) "alpha", NULL
15633 };
15634
15635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15637 if (!SWIG_IsOK(res1)) {
15638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15639 }
15640 arg1 = reinterpret_cast< wxImage * >(argp1);
15641 {
15642 if (obj1 != Py_None) {
15643 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15644 }
15645 }
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 wxImage_SetAlphaData(arg1,arg2,arg3);
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 resultobj = SWIG_Py_Void();
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15660 PyObject *resultobj = 0;
15661 wxImage *arg1 = (wxImage *) 0 ;
15662 PyObject *result = 0 ;
15663 void *argp1 = 0 ;
15664 int res1 = 0 ;
15665 PyObject *swig_obj[1] ;
15666
15667 if (!args) SWIG_fail;
15668 swig_obj[0] = args;
15669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15670 if (!SWIG_IsOK(res1)) {
15671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15672 }
15673 arg1 = reinterpret_cast< wxImage * >(argp1);
15674 {
15675 PyThreadState* __tstate = wxPyBeginAllowThreads();
15676 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15677 wxPyEndAllowThreads(__tstate);
15678 if (PyErr_Occurred()) SWIG_fail;
15679 }
15680 resultobj = result;
15681 return resultobj;
15682 fail:
15683 return NULL;
15684 }
15685
15686
15687 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15688 PyObject *resultobj = 0;
15689 wxImage *arg1 = (wxImage *) 0 ;
15690 buffer arg2 ;
15691 int arg3 ;
15692 void *argp1 = 0 ;
15693 int res1 = 0 ;
15694 PyObject * obj0 = 0 ;
15695 PyObject * obj1 = 0 ;
15696 char * kwnames[] = {
15697 (char *) "self",(char *) "alpha", NULL
15698 };
15699
15700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15702 if (!SWIG_IsOK(res1)) {
15703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15704 }
15705 arg1 = reinterpret_cast< wxImage * >(argp1);
15706 {
15707 if (obj1 != Py_None) {
15708 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15709 }
15710 }
15711 {
15712 PyThreadState* __tstate = wxPyBeginAllowThreads();
15713 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15714 wxPyEndAllowThreads(__tstate);
15715 if (PyErr_Occurred()) SWIG_fail;
15716 }
15717 resultobj = SWIG_Py_Void();
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj = 0;
15726 wxImage *arg1 = (wxImage *) 0 ;
15727 byte arg2 ;
15728 byte arg3 ;
15729 byte arg4 ;
15730 void *argp1 = 0 ;
15731 int res1 = 0 ;
15732 unsigned char val2 ;
15733 int ecode2 = 0 ;
15734 unsigned char val3 ;
15735 int ecode3 = 0 ;
15736 unsigned char val4 ;
15737 int ecode4 = 0 ;
15738 PyObject * obj0 = 0 ;
15739 PyObject * obj1 = 0 ;
15740 PyObject * obj2 = 0 ;
15741 PyObject * obj3 = 0 ;
15742 char * kwnames[] = {
15743 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15744 };
15745
15746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15750 }
15751 arg1 = reinterpret_cast< wxImage * >(argp1);
15752 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15753 if (!SWIG_IsOK(ecode2)) {
15754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15755 }
15756 arg2 = static_cast< byte >(val2);
15757 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15758 if (!SWIG_IsOK(ecode3)) {
15759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15760 }
15761 arg3 = static_cast< byte >(val3);
15762 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15763 if (!SWIG_IsOK(ecode4)) {
15764 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15765 }
15766 arg4 = static_cast< byte >(val4);
15767 {
15768 PyThreadState* __tstate = wxPyBeginAllowThreads();
15769 (arg1)->SetMaskColour(arg2,arg3,arg4);
15770 wxPyEndAllowThreads(__tstate);
15771 if (PyErr_Occurred()) SWIG_fail;
15772 }
15773 resultobj = SWIG_Py_Void();
15774 return resultobj;
15775 fail:
15776 return NULL;
15777 }
15778
15779
15780 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15781 PyObject *resultobj = 0;
15782 wxImage *arg1 = (wxImage *) 0 ;
15783 byte *arg2 = (byte *) 0 ;
15784 byte *arg3 = (byte *) 0 ;
15785 byte *arg4 = (byte *) 0 ;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 byte temp2 ;
15789 int res2 = SWIG_TMPOBJ ;
15790 byte temp3 ;
15791 int res3 = SWIG_TMPOBJ ;
15792 byte temp4 ;
15793 int res4 = SWIG_TMPOBJ ;
15794 PyObject *swig_obj[1] ;
15795
15796 arg2 = &temp2;
15797 arg3 = &temp3;
15798 arg4 = &temp4;
15799 if (!args) SWIG_fail;
15800 swig_obj[0] = args;
15801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15802 if (!SWIG_IsOK(res1)) {
15803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15804 }
15805 arg1 = reinterpret_cast< wxImage * >(argp1);
15806 {
15807 PyThreadState* __tstate = wxPyBeginAllowThreads();
15808 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15809 wxPyEndAllowThreads(__tstate);
15810 if (PyErr_Occurred()) SWIG_fail;
15811 }
15812 resultobj = SWIG_Py_Void();
15813 if (SWIG_IsTmpObj(res2)) {
15814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15815 } else {
15816 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15818 }
15819 if (SWIG_IsTmpObj(res3)) {
15820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15821 } else {
15822 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15824 }
15825 if (SWIG_IsTmpObj(res4)) {
15826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15827 } else {
15828 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15830 }
15831 return resultobj;
15832 fail:
15833 return NULL;
15834 }
15835
15836
15837 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15838 PyObject *resultobj = 0;
15839 wxImage *arg1 = (wxImage *) 0 ;
15840 byte result;
15841 void *argp1 = 0 ;
15842 int res1 = 0 ;
15843 PyObject *swig_obj[1] ;
15844
15845 if (!args) SWIG_fail;
15846 swig_obj[0] = args;
15847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15848 if (!SWIG_IsOK(res1)) {
15849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15850 }
15851 arg1 = reinterpret_cast< wxImage * >(argp1);
15852 {
15853 PyThreadState* __tstate = wxPyBeginAllowThreads();
15854 result = (byte)(arg1)->GetMaskRed();
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15859 return resultobj;
15860 fail:
15861 return NULL;
15862 }
15863
15864
15865 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15866 PyObject *resultobj = 0;
15867 wxImage *arg1 = (wxImage *) 0 ;
15868 byte result;
15869 void *argp1 = 0 ;
15870 int res1 = 0 ;
15871 PyObject *swig_obj[1] ;
15872
15873 if (!args) SWIG_fail;
15874 swig_obj[0] = args;
15875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15876 if (!SWIG_IsOK(res1)) {
15877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15878 }
15879 arg1 = reinterpret_cast< wxImage * >(argp1);
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 result = (byte)(arg1)->GetMaskGreen();
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15887 return resultobj;
15888 fail:
15889 return NULL;
15890 }
15891
15892
15893 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15894 PyObject *resultobj = 0;
15895 wxImage *arg1 = (wxImage *) 0 ;
15896 byte result;
15897 void *argp1 = 0 ;
15898 int res1 = 0 ;
15899 PyObject *swig_obj[1] ;
15900
15901 if (!args) SWIG_fail;
15902 swig_obj[0] = args;
15903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15904 if (!SWIG_IsOK(res1)) {
15905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15906 }
15907 arg1 = reinterpret_cast< wxImage * >(argp1);
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 result = (byte)(arg1)->GetMaskBlue();
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15922 PyObject *resultobj = 0;
15923 wxImage *arg1 = (wxImage *) 0 ;
15924 bool arg2 = (bool) true ;
15925 void *argp1 = 0 ;
15926 int res1 = 0 ;
15927 bool val2 ;
15928 int ecode2 = 0 ;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char * kwnames[] = {
15932 (char *) "self",(char *) "mask", NULL
15933 };
15934
15935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15937 if (!SWIG_IsOK(res1)) {
15938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15939 }
15940 arg1 = reinterpret_cast< wxImage * >(argp1);
15941 if (obj1) {
15942 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15943 if (!SWIG_IsOK(ecode2)) {
15944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15945 }
15946 arg2 = static_cast< bool >(val2);
15947 }
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 (arg1)->SetMask(arg2);
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_Py_Void();
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxImage *arg1 = (wxImage *) 0 ;
15964 bool result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15974 }
15975 arg1 = reinterpret_cast< wxImage * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = (bool)(arg1)->HasMask();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 {
15983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15984 }
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15992 PyObject *resultobj = 0;
15993 wxImage *arg1 = (wxImage *) 0 ;
15994 double arg2 ;
15995 wxPoint *arg3 = 0 ;
15996 bool arg4 = (bool) true ;
15997 wxPoint *arg5 = (wxPoint *) NULL ;
15998 SwigValueWrapper<wxImage > result;
15999 void *argp1 = 0 ;
16000 int res1 = 0 ;
16001 double val2 ;
16002 int ecode2 = 0 ;
16003 wxPoint temp3 ;
16004 bool val4 ;
16005 int ecode4 = 0 ;
16006 void *argp5 = 0 ;
16007 int res5 = 0 ;
16008 PyObject * obj0 = 0 ;
16009 PyObject * obj1 = 0 ;
16010 PyObject * obj2 = 0 ;
16011 PyObject * obj3 = 0 ;
16012 PyObject * obj4 = 0 ;
16013 char * kwnames[] = {
16014 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16015 };
16016
16017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16019 if (!SWIG_IsOK(res1)) {
16020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16021 }
16022 arg1 = reinterpret_cast< wxImage * >(argp1);
16023 ecode2 = SWIG_AsVal_double(obj1, &val2);
16024 if (!SWIG_IsOK(ecode2)) {
16025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16026 }
16027 arg2 = static_cast< double >(val2);
16028 {
16029 arg3 = &temp3;
16030 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16031 }
16032 if (obj3) {
16033 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16034 if (!SWIG_IsOK(ecode4)) {
16035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16036 }
16037 arg4 = static_cast< bool >(val4);
16038 }
16039 if (obj4) {
16040 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16041 if (!SWIG_IsOK(res5)) {
16042 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16043 }
16044 arg5 = reinterpret_cast< wxPoint * >(argp5);
16045 }
16046 {
16047 PyThreadState* __tstate = wxPyBeginAllowThreads();
16048 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16049 wxPyEndAllowThreads(__tstate);
16050 if (PyErr_Occurred()) SWIG_fail;
16051 }
16052 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj = 0;
16061 wxImage *arg1 = (wxImage *) 0 ;
16062 bool arg2 = (bool) true ;
16063 SwigValueWrapper<wxImage > result;
16064 void *argp1 = 0 ;
16065 int res1 = 0 ;
16066 bool val2 ;
16067 int ecode2 = 0 ;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 char * kwnames[] = {
16071 (char *) "self",(char *) "clockwise", NULL
16072 };
16073
16074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16076 if (!SWIG_IsOK(res1)) {
16077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16078 }
16079 arg1 = reinterpret_cast< wxImage * >(argp1);
16080 if (obj1) {
16081 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16082 if (!SWIG_IsOK(ecode2)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16084 }
16085 arg2 = static_cast< bool >(val2);
16086 }
16087 {
16088 PyThreadState* __tstate = wxPyBeginAllowThreads();
16089 result = (arg1)->Rotate90(arg2);
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16094 return resultobj;
16095 fail:
16096 return NULL;
16097 }
16098
16099
16100 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16101 PyObject *resultobj = 0;
16102 wxImage *arg1 = (wxImage *) 0 ;
16103 bool arg2 = (bool) true ;
16104 SwigValueWrapper<wxImage > result;
16105 void *argp1 = 0 ;
16106 int res1 = 0 ;
16107 bool val2 ;
16108 int ecode2 = 0 ;
16109 PyObject * obj0 = 0 ;
16110 PyObject * obj1 = 0 ;
16111 char * kwnames[] = {
16112 (char *) "self",(char *) "horizontally", NULL
16113 };
16114
16115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) 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_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16119 }
16120 arg1 = reinterpret_cast< wxImage * >(argp1);
16121 if (obj1) {
16122 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16123 if (!SWIG_IsOK(ecode2)) {
16124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16125 }
16126 arg2 = static_cast< bool >(val2);
16127 }
16128 {
16129 PyThreadState* __tstate = wxPyBeginAllowThreads();
16130 result = (arg1)->Mirror(arg2);
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj = 0;
16143 wxImage *arg1 = (wxImage *) 0 ;
16144 byte arg2 ;
16145 byte arg3 ;
16146 byte arg4 ;
16147 byte arg5 ;
16148 byte arg6 ;
16149 byte arg7 ;
16150 void *argp1 = 0 ;
16151 int res1 = 0 ;
16152 unsigned char val2 ;
16153 int ecode2 = 0 ;
16154 unsigned char val3 ;
16155 int ecode3 = 0 ;
16156 unsigned char val4 ;
16157 int ecode4 = 0 ;
16158 unsigned char val5 ;
16159 int ecode5 = 0 ;
16160 unsigned char val6 ;
16161 int ecode6 = 0 ;
16162 unsigned char val7 ;
16163 int ecode7 = 0 ;
16164 PyObject * obj0 = 0 ;
16165 PyObject * obj1 = 0 ;
16166 PyObject * obj2 = 0 ;
16167 PyObject * obj3 = 0 ;
16168 PyObject * obj4 = 0 ;
16169 PyObject * obj5 = 0 ;
16170 PyObject * obj6 = 0 ;
16171 char * kwnames[] = {
16172 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16173 };
16174
16175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16179 }
16180 arg1 = reinterpret_cast< wxImage * >(argp1);
16181 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16182 if (!SWIG_IsOK(ecode2)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16184 }
16185 arg2 = static_cast< byte >(val2);
16186 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16187 if (!SWIG_IsOK(ecode3)) {
16188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16189 }
16190 arg3 = static_cast< byte >(val3);
16191 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16192 if (!SWIG_IsOK(ecode4)) {
16193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16194 }
16195 arg4 = static_cast< byte >(val4);
16196 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16197 if (!SWIG_IsOK(ecode5)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16199 }
16200 arg5 = static_cast< byte >(val5);
16201 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16202 if (!SWIG_IsOK(ecode6)) {
16203 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16204 }
16205 arg6 = static_cast< byte >(val6);
16206 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16207 if (!SWIG_IsOK(ecode7)) {
16208 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16209 }
16210 arg7 = static_cast< byte >(val7);
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16214 wxPyEndAllowThreads(__tstate);
16215 if (PyErr_Occurred()) SWIG_fail;
16216 }
16217 resultobj = SWIG_Py_Void();
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16225 PyObject *resultobj = 0;
16226 wxImage *arg1 = (wxImage *) 0 ;
16227 double arg2 = (double) 0.299 ;
16228 double arg3 = (double) 0.587 ;
16229 double arg4 = (double) 0.114 ;
16230 SwigValueWrapper<wxImage > result;
16231 void *argp1 = 0 ;
16232 int res1 = 0 ;
16233 double val2 ;
16234 int ecode2 = 0 ;
16235 double val3 ;
16236 int ecode3 = 0 ;
16237 double val4 ;
16238 int ecode4 = 0 ;
16239 PyObject * obj0 = 0 ;
16240 PyObject * obj1 = 0 ;
16241 PyObject * obj2 = 0 ;
16242 PyObject * obj3 = 0 ;
16243 char * kwnames[] = {
16244 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16245 };
16246
16247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16249 if (!SWIG_IsOK(res1)) {
16250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16251 }
16252 arg1 = reinterpret_cast< wxImage * >(argp1);
16253 if (obj1) {
16254 ecode2 = SWIG_AsVal_double(obj1, &val2);
16255 if (!SWIG_IsOK(ecode2)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16257 }
16258 arg2 = static_cast< double >(val2);
16259 }
16260 if (obj2) {
16261 ecode3 = SWIG_AsVal_double(obj2, &val3);
16262 if (!SWIG_IsOK(ecode3)) {
16263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16264 }
16265 arg3 = static_cast< double >(val3);
16266 }
16267 if (obj3) {
16268 ecode4 = SWIG_AsVal_double(obj3, &val4);
16269 if (!SWIG_IsOK(ecode4)) {
16270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16271 }
16272 arg4 = static_cast< double >(val4);
16273 }
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16281 return resultobj;
16282 fail:
16283 return NULL;
16284 }
16285
16286
16287 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16288 PyObject *resultobj = 0;
16289 wxImage *arg1 = (wxImage *) 0 ;
16290 byte arg2 ;
16291 byte arg3 ;
16292 byte arg4 ;
16293 SwigValueWrapper<wxImage > result;
16294 void *argp1 = 0 ;
16295 int res1 = 0 ;
16296 unsigned char val2 ;
16297 int ecode2 = 0 ;
16298 unsigned char val3 ;
16299 int ecode3 = 0 ;
16300 unsigned char val4 ;
16301 int ecode4 = 0 ;
16302 PyObject * obj0 = 0 ;
16303 PyObject * obj1 = 0 ;
16304 PyObject * obj2 = 0 ;
16305 PyObject * obj3 = 0 ;
16306 char * kwnames[] = {
16307 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16308 };
16309
16310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16312 if (!SWIG_IsOK(res1)) {
16313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16314 }
16315 arg1 = reinterpret_cast< wxImage * >(argp1);
16316 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16317 if (!SWIG_IsOK(ecode2)) {
16318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16319 }
16320 arg2 = static_cast< byte >(val2);
16321 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16322 if (!SWIG_IsOK(ecode3)) {
16323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16324 }
16325 arg3 = static_cast< byte >(val3);
16326 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16327 if (!SWIG_IsOK(ecode4)) {
16328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16329 }
16330 arg4 = static_cast< byte >(val4);
16331 {
16332 PyThreadState* __tstate = wxPyBeginAllowThreads();
16333 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16334 wxPyEndAllowThreads(__tstate);
16335 if (PyErr_Occurred()) SWIG_fail;
16336 }
16337 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16338 return resultobj;
16339 fail:
16340 return NULL;
16341 }
16342
16343
16344 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16345 PyObject *resultobj = 0;
16346 wxImage *arg1 = (wxImage *) 0 ;
16347 wxString *arg2 = 0 ;
16348 wxString *arg3 = 0 ;
16349 void *argp1 = 0 ;
16350 int res1 = 0 ;
16351 bool temp2 = false ;
16352 bool temp3 = false ;
16353 PyObject * obj0 = 0 ;
16354 PyObject * obj1 = 0 ;
16355 PyObject * obj2 = 0 ;
16356 char * kwnames[] = {
16357 (char *) "self",(char *) "name",(char *) "value", NULL
16358 };
16359
16360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16362 if (!SWIG_IsOK(res1)) {
16363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16364 }
16365 arg1 = reinterpret_cast< wxImage * >(argp1);
16366 {
16367 arg2 = wxString_in_helper(obj1);
16368 if (arg2 == NULL) SWIG_fail;
16369 temp2 = true;
16370 }
16371 {
16372 arg3 = wxString_in_helper(obj2);
16373 if (arg3 == NULL) SWIG_fail;
16374 temp3 = true;
16375 }
16376 {
16377 PyThreadState* __tstate = wxPyBeginAllowThreads();
16378 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16379 wxPyEndAllowThreads(__tstate);
16380 if (PyErr_Occurred()) SWIG_fail;
16381 }
16382 resultobj = SWIG_Py_Void();
16383 {
16384 if (temp2)
16385 delete arg2;
16386 }
16387 {
16388 if (temp3)
16389 delete arg3;
16390 }
16391 return resultobj;
16392 fail:
16393 {
16394 if (temp2)
16395 delete arg2;
16396 }
16397 {
16398 if (temp3)
16399 delete arg3;
16400 }
16401 return NULL;
16402 }
16403
16404
16405 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16406 PyObject *resultobj = 0;
16407 wxImage *arg1 = (wxImage *) 0 ;
16408 wxString *arg2 = 0 ;
16409 int arg3 ;
16410 void *argp1 = 0 ;
16411 int res1 = 0 ;
16412 bool temp2 = false ;
16413 int val3 ;
16414 int ecode3 = 0 ;
16415 PyObject * obj0 = 0 ;
16416 PyObject * obj1 = 0 ;
16417 PyObject * obj2 = 0 ;
16418 char * kwnames[] = {
16419 (char *) "self",(char *) "name",(char *) "value", NULL
16420 };
16421
16422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16426 }
16427 arg1 = reinterpret_cast< wxImage * >(argp1);
16428 {
16429 arg2 = wxString_in_helper(obj1);
16430 if (arg2 == NULL) SWIG_fail;
16431 temp2 = true;
16432 }
16433 ecode3 = SWIG_AsVal_int(obj2, &val3);
16434 if (!SWIG_IsOK(ecode3)) {
16435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16436 }
16437 arg3 = static_cast< int >(val3);
16438 {
16439 PyThreadState* __tstate = wxPyBeginAllowThreads();
16440 (arg1)->SetOption((wxString const &)*arg2,arg3);
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 resultobj = SWIG_Py_Void();
16445 {
16446 if (temp2)
16447 delete arg2;
16448 }
16449 return resultobj;
16450 fail:
16451 {
16452 if (temp2)
16453 delete arg2;
16454 }
16455 return NULL;
16456 }
16457
16458
16459 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16460 PyObject *resultobj = 0;
16461 wxImage *arg1 = (wxImage *) 0 ;
16462 wxString *arg2 = 0 ;
16463 wxString result;
16464 void *argp1 = 0 ;
16465 int res1 = 0 ;
16466 bool temp2 = false ;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 char * kwnames[] = {
16470 (char *) "self",(char *) "name", NULL
16471 };
16472
16473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16475 if (!SWIG_IsOK(res1)) {
16476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16477 }
16478 arg1 = reinterpret_cast< wxImage * >(argp1);
16479 {
16480 arg2 = wxString_in_helper(obj1);
16481 if (arg2 == NULL) SWIG_fail;
16482 temp2 = true;
16483 }
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 {
16491 #if wxUSE_UNICODE
16492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16493 #else
16494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16495 #endif
16496 }
16497 {
16498 if (temp2)
16499 delete arg2;
16500 }
16501 return resultobj;
16502 fail:
16503 {
16504 if (temp2)
16505 delete arg2;
16506 }
16507 return NULL;
16508 }
16509
16510
16511 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16512 PyObject *resultobj = 0;
16513 wxImage *arg1 = (wxImage *) 0 ;
16514 wxString *arg2 = 0 ;
16515 int result;
16516 void *argp1 = 0 ;
16517 int res1 = 0 ;
16518 bool temp2 = false ;
16519 PyObject * obj0 = 0 ;
16520 PyObject * obj1 = 0 ;
16521 char * kwnames[] = {
16522 (char *) "self",(char *) "name", NULL
16523 };
16524
16525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16527 if (!SWIG_IsOK(res1)) {
16528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16529 }
16530 arg1 = reinterpret_cast< wxImage * >(argp1);
16531 {
16532 arg2 = wxString_in_helper(obj1);
16533 if (arg2 == NULL) SWIG_fail;
16534 temp2 = true;
16535 }
16536 {
16537 PyThreadState* __tstate = wxPyBeginAllowThreads();
16538 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16539 wxPyEndAllowThreads(__tstate);
16540 if (PyErr_Occurred()) SWIG_fail;
16541 }
16542 resultobj = SWIG_From_int(static_cast< int >(result));
16543 {
16544 if (temp2)
16545 delete arg2;
16546 }
16547 return resultobj;
16548 fail:
16549 {
16550 if (temp2)
16551 delete arg2;
16552 }
16553 return NULL;
16554 }
16555
16556
16557 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj = 0;
16559 wxImage *arg1 = (wxImage *) 0 ;
16560 wxString *arg2 = 0 ;
16561 bool result;
16562 void *argp1 = 0 ;
16563 int res1 = 0 ;
16564 bool temp2 = false ;
16565 PyObject * obj0 = 0 ;
16566 PyObject * obj1 = 0 ;
16567 char * kwnames[] = {
16568 (char *) "self",(char *) "name", NULL
16569 };
16570
16571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16573 if (!SWIG_IsOK(res1)) {
16574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16575 }
16576 arg1 = reinterpret_cast< wxImage * >(argp1);
16577 {
16578 arg2 = wxString_in_helper(obj1);
16579 if (arg2 == NULL) SWIG_fail;
16580 temp2 = true;
16581 }
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16585 wxPyEndAllowThreads(__tstate);
16586 if (PyErr_Occurred()) SWIG_fail;
16587 }
16588 {
16589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16590 }
16591 {
16592 if (temp2)
16593 delete arg2;
16594 }
16595 return resultobj;
16596 fail:
16597 {
16598 if (temp2)
16599 delete arg2;
16600 }
16601 return NULL;
16602 }
16603
16604
16605 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj = 0;
16607 wxImage *arg1 = (wxImage *) 0 ;
16608 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16609 unsigned long result;
16610 void *argp1 = 0 ;
16611 int res1 = 0 ;
16612 unsigned long val2 ;
16613 int ecode2 = 0 ;
16614 PyObject * obj0 = 0 ;
16615 PyObject * obj1 = 0 ;
16616 char * kwnames[] = {
16617 (char *) "self",(char *) "stopafter", NULL
16618 };
16619
16620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16622 if (!SWIG_IsOK(res1)) {
16623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16624 }
16625 arg1 = reinterpret_cast< wxImage * >(argp1);
16626 if (obj1) {
16627 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16628 if (!SWIG_IsOK(ecode2)) {
16629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16630 }
16631 arg2 = static_cast< unsigned long >(val2);
16632 }
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 result = (unsigned long)(arg1)->CountColours(arg2);
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16647 PyObject *resultobj = 0;
16648 wxImage *arg1 = (wxImage *) 0 ;
16649 wxImageHistogram *arg2 = 0 ;
16650 unsigned long result;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 void *argp2 = 0 ;
16654 int res2 = 0 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 char * kwnames[] = {
16658 (char *) "self",(char *) "h", NULL
16659 };
16660
16661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16665 }
16666 arg1 = reinterpret_cast< wxImage * >(argp1);
16667 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16668 if (!SWIG_IsOK(res2)) {
16669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16670 }
16671 if (!argp2) {
16672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16673 }
16674 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj = 0;
16690 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16691 void *argp1 = 0 ;
16692 int res1 = 0 ;
16693 PyObject * obj0 = 0 ;
16694 char * kwnames[] = {
16695 (char *) "handler", NULL
16696 };
16697
16698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16700 if (!SWIG_IsOK(res1)) {
16701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16702 }
16703 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16704 {
16705 PyThreadState* __tstate = wxPyBeginAllowThreads();
16706 wxImage::AddHandler(arg1);
16707 wxPyEndAllowThreads(__tstate);
16708 if (PyErr_Occurred()) SWIG_fail;
16709 }
16710 resultobj = SWIG_Py_Void();
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj = 0;
16719 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16720 void *argp1 = 0 ;
16721 int res1 = 0 ;
16722 PyObject * obj0 = 0 ;
16723 char * kwnames[] = {
16724 (char *) "handler", NULL
16725 };
16726
16727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16729 if (!SWIG_IsOK(res1)) {
16730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16731 }
16732 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 wxImage::InsertHandler(arg1);
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 resultobj = SWIG_Py_Void();
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16747 PyObject *resultobj = 0;
16748 wxString *arg1 = 0 ;
16749 bool result;
16750 bool temp1 = false ;
16751 PyObject * obj0 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "name", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16757 {
16758 arg1 = wxString_in_helper(obj0);
16759 if (arg1 == NULL) SWIG_fail;
16760 temp1 = true;
16761 }
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 {
16769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16770 }
16771 {
16772 if (temp1)
16773 delete arg1;
16774 }
16775 return resultobj;
16776 fail:
16777 {
16778 if (temp1)
16779 delete arg1;
16780 }
16781 return NULL;
16782 }
16783
16784
16785 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16786 PyObject *resultobj = 0;
16787 PyObject *result = 0 ;
16788
16789 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16790 {
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = (PyObject *)wxImage_GetHandlers();
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 resultobj = result;
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16804 PyObject *resultobj = 0;
16805 wxString result;
16806
16807 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 result = wxImage::GetImageExtWildcard();
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 {
16815 #if wxUSE_UNICODE
16816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16817 #else
16818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16819 #endif
16820 }
16821 return resultobj;
16822 fail:
16823 return NULL;
16824 }
16825
16826
16827 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16828 PyObject *resultobj = 0;
16829 wxImage *arg1 = (wxImage *) 0 ;
16830 int arg2 = (int) -1 ;
16831 wxBitmap result;
16832 void *argp1 = 0 ;
16833 int res1 = 0 ;
16834 int val2 ;
16835 int ecode2 = 0 ;
16836 PyObject * obj0 = 0 ;
16837 PyObject * obj1 = 0 ;
16838 char * kwnames[] = {
16839 (char *) "self",(char *) "depth", NULL
16840 };
16841
16842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16844 if (!SWIG_IsOK(res1)) {
16845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16846 }
16847 arg1 = reinterpret_cast< wxImage * >(argp1);
16848 if (obj1) {
16849 ecode2 = SWIG_AsVal_int(obj1, &val2);
16850 if (!SWIG_IsOK(ecode2)) {
16851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16852 }
16853 arg2 = static_cast< int >(val2);
16854 }
16855 {
16856 if (!wxPyCheckForApp()) SWIG_fail;
16857 PyThreadState* __tstate = wxPyBeginAllowThreads();
16858 result = wxImage_ConvertToBitmap(arg1,arg2);
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj = 0;
16871 wxImage *arg1 = (wxImage *) 0 ;
16872 byte arg2 ;
16873 byte arg3 ;
16874 byte arg4 ;
16875 wxBitmap result;
16876 void *argp1 = 0 ;
16877 int res1 = 0 ;
16878 unsigned char val2 ;
16879 int ecode2 = 0 ;
16880 unsigned char val3 ;
16881 int ecode3 = 0 ;
16882 unsigned char val4 ;
16883 int ecode4 = 0 ;
16884 PyObject * obj0 = 0 ;
16885 PyObject * obj1 = 0 ;
16886 PyObject * obj2 = 0 ;
16887 PyObject * obj3 = 0 ;
16888 char * kwnames[] = {
16889 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16890 };
16891
16892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16894 if (!SWIG_IsOK(res1)) {
16895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16896 }
16897 arg1 = reinterpret_cast< wxImage * >(argp1);
16898 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16899 if (!SWIG_IsOK(ecode2)) {
16900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16901 }
16902 arg2 = static_cast< byte >(val2);
16903 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16904 if (!SWIG_IsOK(ecode3)) {
16905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16906 }
16907 arg3 = static_cast< byte >(val3);
16908 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16909 if (!SWIG_IsOK(ecode4)) {
16910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16911 }
16912 arg4 = static_cast< byte >(val4);
16913 {
16914 if (!wxPyCheckForApp()) SWIG_fail;
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16917 wxPyEndAllowThreads(__tstate);
16918 if (PyErr_Occurred()) SWIG_fail;
16919 }
16920 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16921 return resultobj;
16922 fail:
16923 return NULL;
16924 }
16925
16926
16927 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16928 PyObject *resultobj = 0;
16929 wxImage *arg1 = (wxImage *) 0 ;
16930 double arg2 ;
16931 void *argp1 = 0 ;
16932 int res1 = 0 ;
16933 double val2 ;
16934 int ecode2 = 0 ;
16935 PyObject * obj0 = 0 ;
16936 PyObject * obj1 = 0 ;
16937 char * kwnames[] = {
16938 (char *) "self",(char *) "angle", NULL
16939 };
16940
16941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16943 if (!SWIG_IsOK(res1)) {
16944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16945 }
16946 arg1 = reinterpret_cast< wxImage * >(argp1);
16947 ecode2 = SWIG_AsVal_double(obj1, &val2);
16948 if (!SWIG_IsOK(ecode2)) {
16949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16950 }
16951 arg2 = static_cast< double >(val2);
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 (arg1)->RotateHue(arg2);
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 resultobj = SWIG_Py_Void();
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj = 0;
16967 wxImage_RGBValue arg1 ;
16968 wxImage_HSVValue result;
16969 void *argp1 ;
16970 int res1 = 0 ;
16971 PyObject * obj0 = 0 ;
16972 char * kwnames[] = {
16973 (char *) "rgb", NULL
16974 };
16975
16976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16977 {
16978 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16979 if (!SWIG_IsOK(res1)) {
16980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16981 }
16982 if (!argp1) {
16983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16984 } else {
16985 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16986 arg1 = *temp;
16987 if (SWIG_IsNewObj(res1)) delete temp;
16988 }
16989 }
16990 {
16991 PyThreadState* __tstate = wxPyBeginAllowThreads();
16992 result = wxImage::RGBtoHSV(arg1);
16993 wxPyEndAllowThreads(__tstate);
16994 if (PyErr_Occurred()) SWIG_fail;
16995 }
16996 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16997 return resultobj;
16998 fail:
16999 return NULL;
17000 }
17001
17002
17003 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17004 PyObject *resultobj = 0;
17005 wxImage_HSVValue arg1 ;
17006 wxImage_RGBValue result;
17007 void *argp1 ;
17008 int res1 = 0 ;
17009 PyObject * obj0 = 0 ;
17010 char * kwnames[] = {
17011 (char *) "hsv", NULL
17012 };
17013
17014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17015 {
17016 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17017 if (!SWIG_IsOK(res1)) {
17018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17019 }
17020 if (!argp1) {
17021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17022 } else {
17023 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17024 arg1 = *temp;
17025 if (SWIG_IsNewObj(res1)) delete temp;
17026 }
17027 }
17028 {
17029 PyThreadState* __tstate = wxPyBeginAllowThreads();
17030 result = wxImage::HSVtoRGB(arg1);
17031 wxPyEndAllowThreads(__tstate);
17032 if (PyErr_Occurred()) SWIG_fail;
17033 }
17034 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17035 return resultobj;
17036 fail:
17037 return NULL;
17038 }
17039
17040
17041 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17042 PyObject *obj;
17043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17044 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17045 return SWIG_Py_Void();
17046 }
17047
17048 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17049 return SWIG_Python_InitShadowInstance(args);
17050 }
17051
17052 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17053 PyObject *resultobj = 0;
17054 int arg1 ;
17055 int arg2 ;
17056 buffer arg3 ;
17057 int arg4 ;
17058 buffer arg5 = (buffer) NULL ;
17059 int arg6 = (int) 0 ;
17060 wxImage *result = 0 ;
17061 int val1 ;
17062 int ecode1 = 0 ;
17063 int val2 ;
17064 int ecode2 = 0 ;
17065 PyObject * obj0 = 0 ;
17066 PyObject * obj1 = 0 ;
17067 PyObject * obj2 = 0 ;
17068 PyObject * obj3 = 0 ;
17069 char * kwnames[] = {
17070 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17071 };
17072
17073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17074 ecode1 = SWIG_AsVal_int(obj0, &val1);
17075 if (!SWIG_IsOK(ecode1)) {
17076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17077 }
17078 arg1 = static_cast< int >(val1);
17079 ecode2 = SWIG_AsVal_int(obj1, &val2);
17080 if (!SWIG_IsOK(ecode2)) {
17081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17082 }
17083 arg2 = static_cast< int >(val2);
17084 {
17085 if (obj2 != Py_None) {
17086 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
17087 }
17088 }
17089 if (obj3) {
17090 {
17091 if (obj3 != Py_None) {
17092 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
17093 }
17094 }
17095 }
17096 {
17097 PyThreadState* __tstate = wxPyBeginAllowThreads();
17098 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17099 wxPyEndAllowThreads(__tstate);
17100 if (PyErr_Occurred()) SWIG_fail;
17101 }
17102 {
17103 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17104 }
17105 return resultobj;
17106 fail:
17107 return NULL;
17108 }
17109
17110
17111 SWIGINTERN int NullImage_set(PyObject *) {
17112 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17113 return 1;
17114 }
17115
17116
17117 SWIGINTERN PyObject *NullImage_get(void) {
17118 PyObject *pyobj = 0;
17119
17120 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17121 return pyobj;
17122 }
17123
17124
17125 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17126 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17127 return 1;
17128 }
17129
17130
17131 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17132 PyObject *pyobj = 0;
17133
17134 {
17135 #if wxUSE_UNICODE
17136 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17137 #else
17138 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17139 #endif
17140 }
17141 return pyobj;
17142 }
17143
17144
17145 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17146 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17147 return 1;
17148 }
17149
17150
17151 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17152 PyObject *pyobj = 0;
17153
17154 {
17155 #if wxUSE_UNICODE
17156 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17157 #else
17158 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17159 #endif
17160 }
17161 return pyobj;
17162 }
17163
17164
17165 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17166 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17167 return 1;
17168 }
17169
17170
17171 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17172 PyObject *pyobj = 0;
17173
17174 {
17175 #if wxUSE_UNICODE
17176 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17177 #else
17178 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17179 #endif
17180 }
17181 return pyobj;
17182 }
17183
17184
17185 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17186 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17187 return 1;
17188 }
17189
17190
17191 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17192 PyObject *pyobj = 0;
17193
17194 {
17195 #if wxUSE_UNICODE
17196 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17197 #else
17198 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17199 #endif
17200 }
17201 return pyobj;
17202 }
17203
17204
17205 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17206 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17207 return 1;
17208 }
17209
17210
17211 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17212 PyObject *pyobj = 0;
17213
17214 {
17215 #if wxUSE_UNICODE
17216 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17217 #else
17218 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17219 #endif
17220 }
17221 return pyobj;
17222 }
17223
17224
17225 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17226 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17227 return 1;
17228 }
17229
17230
17231 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17232 PyObject *pyobj = 0;
17233
17234 {
17235 #if wxUSE_UNICODE
17236 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17237 #else
17238 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17239 #endif
17240 }
17241 return pyobj;
17242 }
17243
17244
17245 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17246 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17247 return 1;
17248 }
17249
17250
17251 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17252 PyObject *pyobj = 0;
17253
17254 {
17255 #if wxUSE_UNICODE
17256 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17257 #else
17258 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17259 #endif
17260 }
17261 return pyobj;
17262 }
17263
17264
17265 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17266 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17267 return 1;
17268 }
17269
17270
17271 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17272 PyObject *pyobj = 0;
17273
17274 {
17275 #if wxUSE_UNICODE
17276 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17277 #else
17278 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17279 #endif
17280 }
17281 return pyobj;
17282 }
17283
17284
17285 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17286 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17287 return 1;
17288 }
17289
17290
17291 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17292 PyObject *pyobj = 0;
17293
17294 {
17295 #if wxUSE_UNICODE
17296 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17297 #else
17298 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17299 #endif
17300 }
17301 return pyobj;
17302 }
17303
17304
17305 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17306 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17307 return 1;
17308 }
17309
17310
17311 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17312 PyObject *pyobj = 0;
17313
17314 {
17315 #if wxUSE_UNICODE
17316 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17317 #else
17318 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17319 #endif
17320 }
17321 return pyobj;
17322 }
17323
17324
17325 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17326 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17327 return 1;
17328 }
17329
17330
17331 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17332 PyObject *pyobj = 0;
17333
17334 {
17335 #if wxUSE_UNICODE
17336 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17337 #else
17338 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17339 #endif
17340 }
17341 return pyobj;
17342 }
17343
17344
17345 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17346 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17347 return 1;
17348 }
17349
17350
17351 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17352 PyObject *pyobj = 0;
17353
17354 {
17355 #if wxUSE_UNICODE
17356 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17357 #else
17358 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17359 #endif
17360 }
17361 return pyobj;
17362 }
17363
17364
17365 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17366 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17367 return 1;
17368 }
17369
17370
17371 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17372 PyObject *pyobj = 0;
17373
17374 {
17375 #if wxUSE_UNICODE
17376 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17377 #else
17378 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17379 #endif
17380 }
17381 return pyobj;
17382 }
17383
17384
17385 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17386 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17387 return 1;
17388 }
17389
17390
17391 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17392 PyObject *pyobj = 0;
17393
17394 {
17395 #if wxUSE_UNICODE
17396 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17397 #else
17398 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17399 #endif
17400 }
17401 return pyobj;
17402 }
17403
17404
17405 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17406 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17407 return 1;
17408 }
17409
17410
17411 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17412 PyObject *pyobj = 0;
17413
17414 {
17415 #if wxUSE_UNICODE
17416 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17417 #else
17418 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17419 #endif
17420 }
17421 return pyobj;
17422 }
17423
17424
17425 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17426 PyObject *resultobj = 0;
17427 wxBMPHandler *result = 0 ;
17428
17429 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17430 {
17431 PyThreadState* __tstate = wxPyBeginAllowThreads();
17432 result = (wxBMPHandler *)new wxBMPHandler();
17433 wxPyEndAllowThreads(__tstate);
17434 if (PyErr_Occurred()) SWIG_fail;
17435 }
17436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17437 return resultobj;
17438 fail:
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 PyObject *obj;
17445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17446 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17447 return SWIG_Py_Void();
17448 }
17449
17450 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17451 return SWIG_Python_InitShadowInstance(args);
17452 }
17453
17454 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17455 PyObject *resultobj = 0;
17456 wxICOHandler *result = 0 ;
17457
17458 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (wxICOHandler *)new wxICOHandler();
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17466 return resultobj;
17467 fail:
17468 return NULL;
17469 }
17470
17471
17472 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17473 PyObject *obj;
17474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17475 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17476 return SWIG_Py_Void();
17477 }
17478
17479 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17480 return SWIG_Python_InitShadowInstance(args);
17481 }
17482
17483 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17484 PyObject *resultobj = 0;
17485 wxCURHandler *result = 0 ;
17486
17487 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 result = (wxCURHandler *)new wxCURHandler();
17491 wxPyEndAllowThreads(__tstate);
17492 if (PyErr_Occurred()) SWIG_fail;
17493 }
17494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502 PyObject *obj;
17503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17504 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17505 return SWIG_Py_Void();
17506 }
17507
17508 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 return SWIG_Python_InitShadowInstance(args);
17510 }
17511
17512 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17513 PyObject *resultobj = 0;
17514 wxANIHandler *result = 0 ;
17515
17516 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17517 {
17518 PyThreadState* __tstate = wxPyBeginAllowThreads();
17519 result = (wxANIHandler *)new wxANIHandler();
17520 wxPyEndAllowThreads(__tstate);
17521 if (PyErr_Occurred()) SWIG_fail;
17522 }
17523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17524 return resultobj;
17525 fail:
17526 return NULL;
17527 }
17528
17529
17530 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17531 PyObject *obj;
17532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17533 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17534 return SWIG_Py_Void();
17535 }
17536
17537 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17538 return SWIG_Python_InitShadowInstance(args);
17539 }
17540
17541 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17542 PyObject *resultobj = 0;
17543 wxPNGHandler *result = 0 ;
17544
17545 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (wxPNGHandler *)new wxPNGHandler();
17549 wxPyEndAllowThreads(__tstate);
17550 if (PyErr_Occurred()) SWIG_fail;
17551 }
17552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17553 return resultobj;
17554 fail:
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17560 PyObject *obj;
17561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17562 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17563 return SWIG_Py_Void();
17564 }
17565
17566 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 return SWIG_Python_InitShadowInstance(args);
17568 }
17569
17570 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17571 PyObject *resultobj = 0;
17572 wxGIFHandler *result = 0 ;
17573
17574 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = (wxGIFHandler *)new wxGIFHandler();
17578 wxPyEndAllowThreads(__tstate);
17579 if (PyErr_Occurred()) SWIG_fail;
17580 }
17581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17582 return resultobj;
17583 fail:
17584 return NULL;
17585 }
17586
17587
17588 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17589 PyObject *obj;
17590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17591 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17592 return SWIG_Py_Void();
17593 }
17594
17595 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 return SWIG_Python_InitShadowInstance(args);
17597 }
17598
17599 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17600 PyObject *resultobj = 0;
17601 wxPCXHandler *result = 0 ;
17602
17603 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (wxPCXHandler *)new wxPCXHandler();
17607 wxPyEndAllowThreads(__tstate);
17608 if (PyErr_Occurred()) SWIG_fail;
17609 }
17610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17611 return resultobj;
17612 fail:
17613 return NULL;
17614 }
17615
17616
17617 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17618 PyObject *obj;
17619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17620 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17621 return SWIG_Py_Void();
17622 }
17623
17624 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17625 return SWIG_Python_InitShadowInstance(args);
17626 }
17627
17628 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17629 PyObject *resultobj = 0;
17630 wxJPEGHandler *result = 0 ;
17631
17632 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 result = (wxJPEGHandler *)new wxJPEGHandler();
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17647 PyObject *obj;
17648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17649 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17650 return SWIG_Py_Void();
17651 }
17652
17653 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17654 return SWIG_Python_InitShadowInstance(args);
17655 }
17656
17657 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17658 PyObject *resultobj = 0;
17659 wxPNMHandler *result = 0 ;
17660
17661 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17662 {
17663 PyThreadState* __tstate = wxPyBeginAllowThreads();
17664 result = (wxPNMHandler *)new wxPNMHandler();
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676 PyObject *obj;
17677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17678 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17679 return SWIG_Py_Void();
17680 }
17681
17682 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17683 return SWIG_Python_InitShadowInstance(args);
17684 }
17685
17686 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17687 PyObject *resultobj = 0;
17688 wxXPMHandler *result = 0 ;
17689
17690 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17691 {
17692 PyThreadState* __tstate = wxPyBeginAllowThreads();
17693 result = (wxXPMHandler *)new wxXPMHandler();
17694 wxPyEndAllowThreads(__tstate);
17695 if (PyErr_Occurred()) SWIG_fail;
17696 }
17697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17698 return resultobj;
17699 fail:
17700 return NULL;
17701 }
17702
17703
17704 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17705 PyObject *obj;
17706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17707 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17708 return SWIG_Py_Void();
17709 }
17710
17711 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17712 return SWIG_Python_InitShadowInstance(args);
17713 }
17714
17715 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17716 PyObject *resultobj = 0;
17717 wxTIFFHandler *result = 0 ;
17718
17719 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17720 {
17721 PyThreadState* __tstate = wxPyBeginAllowThreads();
17722 result = (wxTIFFHandler *)new wxTIFFHandler();
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17734 PyObject *obj;
17735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17736 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17737 return SWIG_Py_Void();
17738 }
17739
17740 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17741 return SWIG_Python_InitShadowInstance(args);
17742 }
17743
17744 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj = 0;
17746 wxImage *arg1 = 0 ;
17747 wxImage *arg2 = 0 ;
17748 int arg3 = (int) 236 ;
17749 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17750 bool result;
17751 void *argp1 = 0 ;
17752 int res1 = 0 ;
17753 void *argp2 = 0 ;
17754 int res2 = 0 ;
17755 int val3 ;
17756 int ecode3 = 0 ;
17757 int val4 ;
17758 int ecode4 = 0 ;
17759 PyObject * obj0 = 0 ;
17760 PyObject * obj1 = 0 ;
17761 PyObject * obj2 = 0 ;
17762 PyObject * obj3 = 0 ;
17763 char * kwnames[] = {
17764 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17765 };
17766
17767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17768 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17769 if (!SWIG_IsOK(res1)) {
17770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17771 }
17772 if (!argp1) {
17773 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17774 }
17775 arg1 = reinterpret_cast< wxImage * >(argp1);
17776 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17777 if (!SWIG_IsOK(res2)) {
17778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17779 }
17780 if (!argp2) {
17781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17782 }
17783 arg2 = reinterpret_cast< wxImage * >(argp2);
17784 if (obj2) {
17785 ecode3 = SWIG_AsVal_int(obj2, &val3);
17786 if (!SWIG_IsOK(ecode3)) {
17787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17788 }
17789 arg3 = static_cast< int >(val3);
17790 }
17791 if (obj3) {
17792 ecode4 = SWIG_AsVal_int(obj3, &val4);
17793 if (!SWIG_IsOK(ecode4)) {
17794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17795 }
17796 arg4 = static_cast< int >(val4);
17797 }
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 {
17805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17806 }
17807 return resultobj;
17808 fail:
17809 return NULL;
17810 }
17811
17812
17813 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17814 PyObject *obj;
17815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17816 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17817 return SWIG_Py_Void();
17818 }
17819
17820 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17821 PyObject *resultobj = 0;
17822 wxEvtHandler *result = 0 ;
17823
17824 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 result = (wxEvtHandler *)new wxEvtHandler();
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839 PyObject *resultobj = 0;
17840 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17841 wxEvtHandler *result = 0 ;
17842 void *argp1 = 0 ;
17843 int res1 = 0 ;
17844 PyObject *swig_obj[1] ;
17845
17846 if (!args) SWIG_fail;
17847 swig_obj[0] = args;
17848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17849 if (!SWIG_IsOK(res1)) {
17850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17851 }
17852 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17853 {
17854 PyThreadState* __tstate = wxPyBeginAllowThreads();
17855 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 {
17860 resultobj = wxPyMake_wxObject(result, 0);
17861 }
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17869 PyObject *resultobj = 0;
17870 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17871 wxEvtHandler *result = 0 ;
17872 void *argp1 = 0 ;
17873 int res1 = 0 ;
17874 PyObject *swig_obj[1] ;
17875
17876 if (!args) SWIG_fail;
17877 swig_obj[0] = args;
17878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17879 if (!SWIG_IsOK(res1)) {
17880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17881 }
17882 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17883 {
17884 PyThreadState* __tstate = wxPyBeginAllowThreads();
17885 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 resultobj = wxPyMake_wxObject(result, 0);
17891 }
17892 return resultobj;
17893 fail:
17894 return NULL;
17895 }
17896
17897
17898 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17899 PyObject *resultobj = 0;
17900 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17901 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17902 void *argp1 = 0 ;
17903 int res1 = 0 ;
17904 void *argp2 = 0 ;
17905 int res2 = 0 ;
17906 PyObject * obj0 = 0 ;
17907 PyObject * obj1 = 0 ;
17908 char * kwnames[] = {
17909 (char *) "self",(char *) "handler", NULL
17910 };
17911
17912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17914 if (!SWIG_IsOK(res1)) {
17915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17916 }
17917 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17918 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17919 if (!SWIG_IsOK(res2)) {
17920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17921 }
17922 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 (arg1)->SetNextHandler(arg2);
17926 wxPyEndAllowThreads(__tstate);
17927 if (PyErr_Occurred()) SWIG_fail;
17928 }
17929 resultobj = SWIG_Py_Void();
17930 return resultobj;
17931 fail:
17932 return NULL;
17933 }
17934
17935
17936 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17937 PyObject *resultobj = 0;
17938 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17939 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17940 void *argp1 = 0 ;
17941 int res1 = 0 ;
17942 void *argp2 = 0 ;
17943 int res2 = 0 ;
17944 PyObject * obj0 = 0 ;
17945 PyObject * obj1 = 0 ;
17946 char * kwnames[] = {
17947 (char *) "self",(char *) "handler", NULL
17948 };
17949
17950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17952 if (!SWIG_IsOK(res1)) {
17953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17954 }
17955 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17957 if (!SWIG_IsOK(res2)) {
17958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17959 }
17960 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17961 {
17962 PyThreadState* __tstate = wxPyBeginAllowThreads();
17963 (arg1)->SetPreviousHandler(arg2);
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 resultobj = SWIG_Py_Void();
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17975 PyObject *resultobj = 0;
17976 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17977 bool result;
17978 void *argp1 = 0 ;
17979 int res1 = 0 ;
17980 PyObject *swig_obj[1] ;
17981
17982 if (!args) SWIG_fail;
17983 swig_obj[0] = args;
17984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17985 if (!SWIG_IsOK(res1)) {
17986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17987 }
17988 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17989 {
17990 PyThreadState* __tstate = wxPyBeginAllowThreads();
17991 result = (bool)(arg1)->GetEvtHandlerEnabled();
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 {
17996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17997 }
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18005 PyObject *resultobj = 0;
18006 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18007 bool arg2 ;
18008 void *argp1 = 0 ;
18009 int res1 = 0 ;
18010 bool val2 ;
18011 int ecode2 = 0 ;
18012 PyObject * obj0 = 0 ;
18013 PyObject * obj1 = 0 ;
18014 char * kwnames[] = {
18015 (char *) "self",(char *) "enabled", NULL
18016 };
18017
18018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18020 if (!SWIG_IsOK(res1)) {
18021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18022 }
18023 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18024 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18025 if (!SWIG_IsOK(ecode2)) {
18026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18027 }
18028 arg2 = static_cast< bool >(val2);
18029 {
18030 PyThreadState* __tstate = wxPyBeginAllowThreads();
18031 (arg1)->SetEvtHandlerEnabled(arg2);
18032 wxPyEndAllowThreads(__tstate);
18033 if (PyErr_Occurred()) SWIG_fail;
18034 }
18035 resultobj = SWIG_Py_Void();
18036 return resultobj;
18037 fail:
18038 return NULL;
18039 }
18040
18041
18042 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18043 PyObject *resultobj = 0;
18044 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18045 wxEvent *arg2 = 0 ;
18046 bool result;
18047 void *argp1 = 0 ;
18048 int res1 = 0 ;
18049 void *argp2 = 0 ;
18050 int res2 = 0 ;
18051 PyObject * obj0 = 0 ;
18052 PyObject * obj1 = 0 ;
18053 char * kwnames[] = {
18054 (char *) "self",(char *) "event", NULL
18055 };
18056
18057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18059 if (!SWIG_IsOK(res1)) {
18060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18061 }
18062 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18063 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18064 if (!SWIG_IsOK(res2)) {
18065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18066 }
18067 if (!argp2) {
18068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18069 }
18070 arg2 = reinterpret_cast< wxEvent * >(argp2);
18071 {
18072 PyThreadState* __tstate = wxPyBeginAllowThreads();
18073 result = (bool)(arg1)->ProcessEvent(*arg2);
18074 wxPyEndAllowThreads(__tstate);
18075 if (PyErr_Occurred()) SWIG_fail;
18076 }
18077 {
18078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18079 }
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj = 0;
18088 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18089 wxEvent *arg2 = 0 ;
18090 void *argp1 = 0 ;
18091 int res1 = 0 ;
18092 void *argp2 = 0 ;
18093 int res2 = 0 ;
18094 PyObject * obj0 = 0 ;
18095 PyObject * obj1 = 0 ;
18096 char * kwnames[] = {
18097 (char *) "self",(char *) "event", NULL
18098 };
18099
18100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18102 if (!SWIG_IsOK(res1)) {
18103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18104 }
18105 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18107 if (!SWIG_IsOK(res2)) {
18108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18109 }
18110 if (!argp2) {
18111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18112 }
18113 arg2 = reinterpret_cast< wxEvent * >(argp2);
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 (arg1)->AddPendingEvent(*arg2);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 resultobj = SWIG_Py_Void();
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18128 PyObject *resultobj = 0;
18129 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18130 void *argp1 = 0 ;
18131 int res1 = 0 ;
18132 PyObject *swig_obj[1] ;
18133
18134 if (!args) SWIG_fail;
18135 swig_obj[0] = args;
18136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18137 if (!SWIG_IsOK(res1)) {
18138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18139 }
18140 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18141 {
18142 PyThreadState* __tstate = wxPyBeginAllowThreads();
18143 (arg1)->ProcessPendingEvents();
18144 wxPyEndAllowThreads(__tstate);
18145 if (PyErr_Occurred()) SWIG_fail;
18146 }
18147 resultobj = SWIG_Py_Void();
18148 return resultobj;
18149 fail:
18150 return NULL;
18151 }
18152
18153
18154 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18155 PyObject *resultobj = 0;
18156 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18157 int arg2 ;
18158 int arg3 ;
18159 int arg4 ;
18160 PyObject *arg5 = (PyObject *) 0 ;
18161 void *argp1 = 0 ;
18162 int res1 = 0 ;
18163 int val2 ;
18164 int ecode2 = 0 ;
18165 int val3 ;
18166 int ecode3 = 0 ;
18167 int val4 ;
18168 int ecode4 = 0 ;
18169 PyObject * obj0 = 0 ;
18170 PyObject * obj1 = 0 ;
18171 PyObject * obj2 = 0 ;
18172 PyObject * obj3 = 0 ;
18173 PyObject * obj4 = 0 ;
18174 char * kwnames[] = {
18175 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18176 };
18177
18178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18180 if (!SWIG_IsOK(res1)) {
18181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18182 }
18183 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18184 ecode2 = SWIG_AsVal_int(obj1, &val2);
18185 if (!SWIG_IsOK(ecode2)) {
18186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18187 }
18188 arg2 = static_cast< int >(val2);
18189 ecode3 = SWIG_AsVal_int(obj2, &val3);
18190 if (!SWIG_IsOK(ecode3)) {
18191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18192 }
18193 arg3 = static_cast< int >(val3);
18194 ecode4 = SWIG_AsVal_int(obj3, &val4);
18195 if (!SWIG_IsOK(ecode4)) {
18196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18197 }
18198 arg4 = static_cast< int >(val4);
18199 arg5 = obj4;
18200 {
18201 PyThreadState* __tstate = wxPyBeginAllowThreads();
18202 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18203 wxPyEndAllowThreads(__tstate);
18204 if (PyErr_Occurred()) SWIG_fail;
18205 }
18206 resultobj = SWIG_Py_Void();
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj = 0;
18215 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18216 int arg2 ;
18217 int arg3 = (int) -1 ;
18218 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18219 bool result;
18220 void *argp1 = 0 ;
18221 int res1 = 0 ;
18222 int val2 ;
18223 int ecode2 = 0 ;
18224 int val3 ;
18225 int ecode3 = 0 ;
18226 int val4 ;
18227 int ecode4 = 0 ;
18228 PyObject * obj0 = 0 ;
18229 PyObject * obj1 = 0 ;
18230 PyObject * obj2 = 0 ;
18231 PyObject * obj3 = 0 ;
18232 char * kwnames[] = {
18233 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18234 };
18235
18236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18238 if (!SWIG_IsOK(res1)) {
18239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18240 }
18241 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18242 ecode2 = SWIG_AsVal_int(obj1, &val2);
18243 if (!SWIG_IsOK(ecode2)) {
18244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18245 }
18246 arg2 = static_cast< int >(val2);
18247 if (obj2) {
18248 ecode3 = SWIG_AsVal_int(obj2, &val3);
18249 if (!SWIG_IsOK(ecode3)) {
18250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18251 }
18252 arg3 = static_cast< int >(val3);
18253 }
18254 if (obj3) {
18255 ecode4 = SWIG_AsVal_int(obj3, &val4);
18256 if (!SWIG_IsOK(ecode4)) {
18257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18258 }
18259 arg4 = static_cast< wxEventType >(val4);
18260 }
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 {
18268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18269 }
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18277 PyObject *resultobj = 0;
18278 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18279 PyObject *arg2 = (PyObject *) 0 ;
18280 bool arg3 = (bool) true ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 bool val3 ;
18284 int ecode3 = 0 ;
18285 PyObject * obj0 = 0 ;
18286 PyObject * obj1 = 0 ;
18287 PyObject * obj2 = 0 ;
18288 char * kwnames[] = {
18289 (char *) "self",(char *) "_self",(char *) "incref", NULL
18290 };
18291
18292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18296 }
18297 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18298 arg2 = obj1;
18299 if (obj2) {
18300 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18301 if (!SWIG_IsOK(ecode3)) {
18302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18303 }
18304 arg3 = static_cast< bool >(val3);
18305 }
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = SWIG_Py_Void();
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18320 PyObject *obj;
18321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18322 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18323 return SWIG_Py_Void();
18324 }
18325
18326 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18327 return SWIG_Python_InitShadowInstance(args);
18328 }
18329
18330 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18331 PyObject *resultobj = 0;
18332 wxEventType result;
18333
18334 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = (wxEventType)wxNewEventType();
18338 wxPyEndAllowThreads(__tstate);
18339 if (PyErr_Occurred()) SWIG_fail;
18340 }
18341 resultobj = SWIG_From_int(static_cast< int >(result));
18342 return resultobj;
18343 fail:
18344 return NULL;
18345 }
18346
18347
18348 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18349 PyObject *resultobj = 0;
18350 wxEvent *arg1 = (wxEvent *) 0 ;
18351 void *argp1 = 0 ;
18352 int res1 = 0 ;
18353 PyObject *swig_obj[1] ;
18354
18355 if (!args) SWIG_fail;
18356 swig_obj[0] = args;
18357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18358 if (!SWIG_IsOK(res1)) {
18359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18360 }
18361 arg1 = reinterpret_cast< wxEvent * >(argp1);
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 delete arg1;
18365
18366 wxPyEndAllowThreads(__tstate);
18367 if (PyErr_Occurred()) SWIG_fail;
18368 }
18369 resultobj = SWIG_Py_Void();
18370 return resultobj;
18371 fail:
18372 return NULL;
18373 }
18374
18375
18376 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18377 PyObject *resultobj = 0;
18378 wxEvent *arg1 = (wxEvent *) 0 ;
18379 wxEventType arg2 ;
18380 void *argp1 = 0 ;
18381 int res1 = 0 ;
18382 int val2 ;
18383 int ecode2 = 0 ;
18384 PyObject * obj0 = 0 ;
18385 PyObject * obj1 = 0 ;
18386 char * kwnames[] = {
18387 (char *) "self",(char *) "typ", NULL
18388 };
18389
18390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18392 if (!SWIG_IsOK(res1)) {
18393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18394 }
18395 arg1 = reinterpret_cast< wxEvent * >(argp1);
18396 ecode2 = SWIG_AsVal_int(obj1, &val2);
18397 if (!SWIG_IsOK(ecode2)) {
18398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18399 }
18400 arg2 = static_cast< wxEventType >(val2);
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 (arg1)->SetEventType(arg2);
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 resultobj = SWIG_Py_Void();
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18415 PyObject *resultobj = 0;
18416 wxEvent *arg1 = (wxEvent *) 0 ;
18417 wxEventType result;
18418 void *argp1 = 0 ;
18419 int res1 = 0 ;
18420 PyObject *swig_obj[1] ;
18421
18422 if (!args) SWIG_fail;
18423 swig_obj[0] = args;
18424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18425 if (!SWIG_IsOK(res1)) {
18426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18427 }
18428 arg1 = reinterpret_cast< wxEvent * >(argp1);
18429 {
18430 PyThreadState* __tstate = wxPyBeginAllowThreads();
18431 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18432 wxPyEndAllowThreads(__tstate);
18433 if (PyErr_Occurred()) SWIG_fail;
18434 }
18435 resultobj = SWIG_From_int(static_cast< int >(result));
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18443 PyObject *resultobj = 0;
18444 wxEvent *arg1 = (wxEvent *) 0 ;
18445 wxObject *result = 0 ;
18446 void *argp1 = 0 ;
18447 int res1 = 0 ;
18448 PyObject *swig_obj[1] ;
18449
18450 if (!args) SWIG_fail;
18451 swig_obj[0] = args;
18452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18453 if (!SWIG_IsOK(res1)) {
18454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18455 }
18456 arg1 = reinterpret_cast< wxEvent * >(argp1);
18457 {
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18460 wxPyEndAllowThreads(__tstate);
18461 if (PyErr_Occurred()) SWIG_fail;
18462 }
18463 {
18464 resultobj = wxPyMake_wxObject(result, (bool)0);
18465 }
18466 return resultobj;
18467 fail:
18468 return NULL;
18469 }
18470
18471
18472 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18473 PyObject *resultobj = 0;
18474 wxEvent *arg1 = (wxEvent *) 0 ;
18475 wxObject *arg2 = (wxObject *) 0 ;
18476 void *argp1 = 0 ;
18477 int res1 = 0 ;
18478 void *argp2 = 0 ;
18479 int res2 = 0 ;
18480 PyObject * obj0 = 0 ;
18481 PyObject * obj1 = 0 ;
18482 char * kwnames[] = {
18483 (char *) "self",(char *) "obj", NULL
18484 };
18485
18486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18488 if (!SWIG_IsOK(res1)) {
18489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18490 }
18491 arg1 = reinterpret_cast< wxEvent * >(argp1);
18492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18493 if (!SWIG_IsOK(res2)) {
18494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18495 }
18496 arg2 = reinterpret_cast< wxObject * >(argp2);
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 (arg1)->SetEventObject(arg2);
18500 wxPyEndAllowThreads(__tstate);
18501 if (PyErr_Occurred()) SWIG_fail;
18502 }
18503 resultobj = SWIG_Py_Void();
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18511 PyObject *resultobj = 0;
18512 wxEvent *arg1 = (wxEvent *) 0 ;
18513 long result;
18514 void *argp1 = 0 ;
18515 int res1 = 0 ;
18516 PyObject *swig_obj[1] ;
18517
18518 if (!args) SWIG_fail;
18519 swig_obj[0] = args;
18520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18521 if (!SWIG_IsOK(res1)) {
18522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18523 }
18524 arg1 = reinterpret_cast< wxEvent * >(argp1);
18525 {
18526 PyThreadState* __tstate = wxPyBeginAllowThreads();
18527 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18528 wxPyEndAllowThreads(__tstate);
18529 if (PyErr_Occurred()) SWIG_fail;
18530 }
18531 resultobj = SWIG_From_long(static_cast< long >(result));
18532 return resultobj;
18533 fail:
18534 return NULL;
18535 }
18536
18537
18538 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18539 PyObject *resultobj = 0;
18540 wxEvent *arg1 = (wxEvent *) 0 ;
18541 long arg2 = (long) 0 ;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 long val2 ;
18545 int ecode2 = 0 ;
18546 PyObject * obj0 = 0 ;
18547 PyObject * obj1 = 0 ;
18548 char * kwnames[] = {
18549 (char *) "self",(char *) "ts", NULL
18550 };
18551
18552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18554 if (!SWIG_IsOK(res1)) {
18555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18556 }
18557 arg1 = reinterpret_cast< wxEvent * >(argp1);
18558 if (obj1) {
18559 ecode2 = SWIG_AsVal_long(obj1, &val2);
18560 if (!SWIG_IsOK(ecode2)) {
18561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18562 }
18563 arg2 = static_cast< long >(val2);
18564 }
18565 {
18566 PyThreadState* __tstate = wxPyBeginAllowThreads();
18567 (arg1)->SetTimestamp(arg2);
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 resultobj = SWIG_Py_Void();
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18579 PyObject *resultobj = 0;
18580 wxEvent *arg1 = (wxEvent *) 0 ;
18581 int result;
18582 void *argp1 = 0 ;
18583 int res1 = 0 ;
18584 PyObject *swig_obj[1] ;
18585
18586 if (!args) SWIG_fail;
18587 swig_obj[0] = args;
18588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18589 if (!SWIG_IsOK(res1)) {
18590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18591 }
18592 arg1 = reinterpret_cast< wxEvent * >(argp1);
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (int)((wxEvent const *)arg1)->GetId();
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 resultobj = SWIG_From_int(static_cast< int >(result));
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj = 0;
18608 wxEvent *arg1 = (wxEvent *) 0 ;
18609 int arg2 ;
18610 void *argp1 = 0 ;
18611 int res1 = 0 ;
18612 int val2 ;
18613 int ecode2 = 0 ;
18614 PyObject * obj0 = 0 ;
18615 PyObject * obj1 = 0 ;
18616 char * kwnames[] = {
18617 (char *) "self",(char *) "Id", NULL
18618 };
18619
18620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18622 if (!SWIG_IsOK(res1)) {
18623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18624 }
18625 arg1 = reinterpret_cast< wxEvent * >(argp1);
18626 ecode2 = SWIG_AsVal_int(obj1, &val2);
18627 if (!SWIG_IsOK(ecode2)) {
18628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18629 }
18630 arg2 = static_cast< int >(val2);
18631 {
18632 PyThreadState* __tstate = wxPyBeginAllowThreads();
18633 (arg1)->SetId(arg2);
18634 wxPyEndAllowThreads(__tstate);
18635 if (PyErr_Occurred()) SWIG_fail;
18636 }
18637 resultobj = SWIG_Py_Void();
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18645 PyObject *resultobj = 0;
18646 wxEvent *arg1 = (wxEvent *) 0 ;
18647 bool result;
18648 void *argp1 = 0 ;
18649 int res1 = 0 ;
18650 PyObject *swig_obj[1] ;
18651
18652 if (!args) SWIG_fail;
18653 swig_obj[0] = args;
18654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18655 if (!SWIG_IsOK(res1)) {
18656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18657 }
18658 arg1 = reinterpret_cast< wxEvent * >(argp1);
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18662 wxPyEndAllowThreads(__tstate);
18663 if (PyErr_Occurred()) SWIG_fail;
18664 }
18665 {
18666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18667 }
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj = 0;
18676 wxEvent *arg1 = (wxEvent *) 0 ;
18677 bool arg2 = (bool) true ;
18678 void *argp1 = 0 ;
18679 int res1 = 0 ;
18680 bool val2 ;
18681 int ecode2 = 0 ;
18682 PyObject * obj0 = 0 ;
18683 PyObject * obj1 = 0 ;
18684 char * kwnames[] = {
18685 (char *) "self",(char *) "skip", NULL
18686 };
18687
18688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18690 if (!SWIG_IsOK(res1)) {
18691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18692 }
18693 arg1 = reinterpret_cast< wxEvent * >(argp1);
18694 if (obj1) {
18695 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18696 if (!SWIG_IsOK(ecode2)) {
18697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18698 }
18699 arg2 = static_cast< bool >(val2);
18700 }
18701 {
18702 PyThreadState* __tstate = wxPyBeginAllowThreads();
18703 (arg1)->Skip(arg2);
18704 wxPyEndAllowThreads(__tstate);
18705 if (PyErr_Occurred()) SWIG_fail;
18706 }
18707 resultobj = SWIG_Py_Void();
18708 return resultobj;
18709 fail:
18710 return NULL;
18711 }
18712
18713
18714 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18715 PyObject *resultobj = 0;
18716 wxEvent *arg1 = (wxEvent *) 0 ;
18717 bool result;
18718 void *argp1 = 0 ;
18719 int res1 = 0 ;
18720 PyObject *swig_obj[1] ;
18721
18722 if (!args) SWIG_fail;
18723 swig_obj[0] = args;
18724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18725 if (!SWIG_IsOK(res1)) {
18726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18727 }
18728 arg1 = reinterpret_cast< wxEvent * >(argp1);
18729 {
18730 PyThreadState* __tstate = wxPyBeginAllowThreads();
18731 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18732 wxPyEndAllowThreads(__tstate);
18733 if (PyErr_Occurred()) SWIG_fail;
18734 }
18735 {
18736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18737 }
18738 return resultobj;
18739 fail:
18740 return NULL;
18741 }
18742
18743
18744 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18745 PyObject *resultobj = 0;
18746 wxEvent *arg1 = (wxEvent *) 0 ;
18747 bool result;
18748 void *argp1 = 0 ;
18749 int res1 = 0 ;
18750 PyObject *swig_obj[1] ;
18751
18752 if (!args) SWIG_fail;
18753 swig_obj[0] = args;
18754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18757 }
18758 arg1 = reinterpret_cast< wxEvent * >(argp1);
18759 {
18760 PyThreadState* __tstate = wxPyBeginAllowThreads();
18761 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18762 wxPyEndAllowThreads(__tstate);
18763 if (PyErr_Occurred()) SWIG_fail;
18764 }
18765 {
18766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18767 }
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18775 PyObject *resultobj = 0;
18776 wxEvent *arg1 = (wxEvent *) 0 ;
18777 int result;
18778 void *argp1 = 0 ;
18779 int res1 = 0 ;
18780 PyObject *swig_obj[1] ;
18781
18782 if (!args) SWIG_fail;
18783 swig_obj[0] = args;
18784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18785 if (!SWIG_IsOK(res1)) {
18786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18787 }
18788 arg1 = reinterpret_cast< wxEvent * >(argp1);
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (int)(arg1)->StopPropagation();
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 resultobj = SWIG_From_int(static_cast< int >(result));
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj = 0;
18804 wxEvent *arg1 = (wxEvent *) 0 ;
18805 int arg2 ;
18806 void *argp1 = 0 ;
18807 int res1 = 0 ;
18808 int val2 ;
18809 int ecode2 = 0 ;
18810 PyObject * obj0 = 0 ;
18811 PyObject * obj1 = 0 ;
18812 char * kwnames[] = {
18813 (char *) "self",(char *) "propagationLevel", NULL
18814 };
18815
18816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18818 if (!SWIG_IsOK(res1)) {
18819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18820 }
18821 arg1 = reinterpret_cast< wxEvent * >(argp1);
18822 ecode2 = SWIG_AsVal_int(obj1, &val2);
18823 if (!SWIG_IsOK(ecode2)) {
18824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18825 }
18826 arg2 = static_cast< int >(val2);
18827 {
18828 PyThreadState* __tstate = wxPyBeginAllowThreads();
18829 (arg1)->ResumePropagation(arg2);
18830 wxPyEndAllowThreads(__tstate);
18831 if (PyErr_Occurred()) SWIG_fail;
18832 }
18833 resultobj = SWIG_Py_Void();
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18841 PyObject *resultobj = 0;
18842 wxEvent *arg1 = (wxEvent *) 0 ;
18843 wxEvent *result = 0 ;
18844 void *argp1 = 0 ;
18845 int res1 = 0 ;
18846 PyObject *swig_obj[1] ;
18847
18848 if (!args) SWIG_fail;
18849 swig_obj[0] = args;
18850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18851 if (!SWIG_IsOK(res1)) {
18852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18853 }
18854 arg1 = reinterpret_cast< wxEvent * >(argp1);
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 result = (wxEvent *)(arg1)->Clone();
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18869 PyObject *obj;
18870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18871 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18872 return SWIG_Py_Void();
18873 }
18874
18875 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18876 PyObject *resultobj = 0;
18877 wxEvent *arg1 = 0 ;
18878 wxPropagationDisabler *result = 0 ;
18879 void *argp1 = 0 ;
18880 int res1 = 0 ;
18881 PyObject * obj0 = 0 ;
18882 char * kwnames[] = {
18883 (char *) "event", NULL
18884 };
18885
18886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18887 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18888 if (!SWIG_IsOK(res1)) {
18889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18890 }
18891 if (!argp1) {
18892 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18893 }
18894 arg1 = reinterpret_cast< wxEvent * >(argp1);
18895 {
18896 PyThreadState* __tstate = wxPyBeginAllowThreads();
18897 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18898 wxPyEndAllowThreads(__tstate);
18899 if (PyErr_Occurred()) SWIG_fail;
18900 }
18901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18909 PyObject *resultobj = 0;
18910 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18911 void *argp1 = 0 ;
18912 int res1 = 0 ;
18913 PyObject *swig_obj[1] ;
18914
18915 if (!args) SWIG_fail;
18916 swig_obj[0] = args;
18917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18918 if (!SWIG_IsOK(res1)) {
18919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18920 }
18921 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 delete arg1;
18925
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 resultobj = SWIG_Py_Void();
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18937 PyObject *obj;
18938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18939 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18940 return SWIG_Py_Void();
18941 }
18942
18943 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18944 return SWIG_Python_InitShadowInstance(args);
18945 }
18946
18947 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18948 PyObject *resultobj = 0;
18949 wxEvent *arg1 = 0 ;
18950 wxPropagateOnce *result = 0 ;
18951 void *argp1 = 0 ;
18952 int res1 = 0 ;
18953 PyObject * obj0 = 0 ;
18954 char * kwnames[] = {
18955 (char *) "event", NULL
18956 };
18957
18958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18959 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18960 if (!SWIG_IsOK(res1)) {
18961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18962 }
18963 if (!argp1) {
18964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18965 }
18966 arg1 = reinterpret_cast< wxEvent * >(argp1);
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18974 return resultobj;
18975 fail:
18976 return NULL;
18977 }
18978
18979
18980 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18981 PyObject *resultobj = 0;
18982 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18983 void *argp1 = 0 ;
18984 int res1 = 0 ;
18985 PyObject *swig_obj[1] ;
18986
18987 if (!args) SWIG_fail;
18988 swig_obj[0] = args;
18989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18990 if (!SWIG_IsOK(res1)) {
18991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18992 }
18993 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18994 {
18995 PyThreadState* __tstate = wxPyBeginAllowThreads();
18996 delete arg1;
18997
18998 wxPyEndAllowThreads(__tstate);
18999 if (PyErr_Occurred()) SWIG_fail;
19000 }
19001 resultobj = SWIG_Py_Void();
19002 return resultobj;
19003 fail:
19004 return NULL;
19005 }
19006
19007
19008 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19009 PyObject *obj;
19010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19011 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19012 return SWIG_Py_Void();
19013 }
19014
19015 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19016 return SWIG_Python_InitShadowInstance(args);
19017 }
19018
19019 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19020 PyObject *resultobj = 0;
19021 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19022 int arg2 = (int) 0 ;
19023 wxCommandEvent *result = 0 ;
19024 int val1 ;
19025 int ecode1 = 0 ;
19026 int val2 ;
19027 int ecode2 = 0 ;
19028 PyObject * obj0 = 0 ;
19029 PyObject * obj1 = 0 ;
19030 char * kwnames[] = {
19031 (char *) "commandType",(char *) "winid", NULL
19032 };
19033
19034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19035 if (obj0) {
19036 ecode1 = SWIG_AsVal_int(obj0, &val1);
19037 if (!SWIG_IsOK(ecode1)) {
19038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19039 }
19040 arg1 = static_cast< wxEventType >(val1);
19041 }
19042 if (obj1) {
19043 ecode2 = SWIG_AsVal_int(obj1, &val2);
19044 if (!SWIG_IsOK(ecode2)) {
19045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19046 }
19047 arg2 = static_cast< int >(val2);
19048 }
19049 {
19050 PyThreadState* __tstate = wxPyBeginAllowThreads();
19051 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19052 wxPyEndAllowThreads(__tstate);
19053 if (PyErr_Occurred()) SWIG_fail;
19054 }
19055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19056 return resultobj;
19057 fail:
19058 return NULL;
19059 }
19060
19061
19062 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19063 PyObject *resultobj = 0;
19064 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19065 int result;
19066 void *argp1 = 0 ;
19067 int res1 = 0 ;
19068 PyObject *swig_obj[1] ;
19069
19070 if (!args) SWIG_fail;
19071 swig_obj[0] = args;
19072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19073 if (!SWIG_IsOK(res1)) {
19074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19075 }
19076 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_From_int(static_cast< int >(result));
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19091 PyObject *resultobj = 0;
19092 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19093 wxString *arg2 = 0 ;
19094 void *argp1 = 0 ;
19095 int res1 = 0 ;
19096 bool temp2 = false ;
19097 PyObject * obj0 = 0 ;
19098 PyObject * obj1 = 0 ;
19099 char * kwnames[] = {
19100 (char *) "self",(char *) "s", NULL
19101 };
19102
19103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19105 if (!SWIG_IsOK(res1)) {
19106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19107 }
19108 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19109 {
19110 arg2 = wxString_in_helper(obj1);
19111 if (arg2 == NULL) SWIG_fail;
19112 temp2 = true;
19113 }
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 (arg1)->SetString((wxString const &)*arg2);
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = SWIG_Py_Void();
19121 {
19122 if (temp2)
19123 delete arg2;
19124 }
19125 return resultobj;
19126 fail:
19127 {
19128 if (temp2)
19129 delete arg2;
19130 }
19131 return NULL;
19132 }
19133
19134
19135 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19136 PyObject *resultobj = 0;
19137 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19138 wxString result;
19139 void *argp1 = 0 ;
19140 int res1 = 0 ;
19141 PyObject *swig_obj[1] ;
19142
19143 if (!args) SWIG_fail;
19144 swig_obj[0] = args;
19145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19146 if (!SWIG_IsOK(res1)) {
19147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19148 }
19149 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 result = ((wxCommandEvent const *)arg1)->GetString();
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 {
19157 #if wxUSE_UNICODE
19158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19159 #else
19160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19161 #endif
19162 }
19163 return resultobj;
19164 fail:
19165 return NULL;
19166 }
19167
19168
19169 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19170 PyObject *resultobj = 0;
19171 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19172 bool result;
19173 void *argp1 = 0 ;
19174 int res1 = 0 ;
19175 PyObject *swig_obj[1] ;
19176
19177 if (!args) SWIG_fail;
19178 swig_obj[0] = args;
19179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19180 if (!SWIG_IsOK(res1)) {
19181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19182 }
19183 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19184 {
19185 PyThreadState* __tstate = wxPyBeginAllowThreads();
19186 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19187 wxPyEndAllowThreads(__tstate);
19188 if (PyErr_Occurred()) SWIG_fail;
19189 }
19190 {
19191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19192 }
19193 return resultobj;
19194 fail:
19195 return NULL;
19196 }
19197
19198
19199 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19200 PyObject *resultobj = 0;
19201 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19202 bool result;
19203 void *argp1 = 0 ;
19204 int res1 = 0 ;
19205 PyObject *swig_obj[1] ;
19206
19207 if (!args) SWIG_fail;
19208 swig_obj[0] = args;
19209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19210 if (!SWIG_IsOK(res1)) {
19211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19212 }
19213 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19214 {
19215 PyThreadState* __tstate = wxPyBeginAllowThreads();
19216 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 {
19221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19222 }
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19230 PyObject *resultobj = 0;
19231 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19232 long arg2 ;
19233 void *argp1 = 0 ;
19234 int res1 = 0 ;
19235 long val2 ;
19236 int ecode2 = 0 ;
19237 PyObject * obj0 = 0 ;
19238 PyObject * obj1 = 0 ;
19239 char * kwnames[] = {
19240 (char *) "self",(char *) "extraLong", NULL
19241 };
19242
19243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19245 if (!SWIG_IsOK(res1)) {
19246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19247 }
19248 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19249 ecode2 = SWIG_AsVal_long(obj1, &val2);
19250 if (!SWIG_IsOK(ecode2)) {
19251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19252 }
19253 arg2 = static_cast< long >(val2);
19254 {
19255 PyThreadState* __tstate = wxPyBeginAllowThreads();
19256 (arg1)->SetExtraLong(arg2);
19257 wxPyEndAllowThreads(__tstate);
19258 if (PyErr_Occurred()) SWIG_fail;
19259 }
19260 resultobj = SWIG_Py_Void();
19261 return resultobj;
19262 fail:
19263 return NULL;
19264 }
19265
19266
19267 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19268 PyObject *resultobj = 0;
19269 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19270 long result;
19271 void *argp1 = 0 ;
19272 int res1 = 0 ;
19273 PyObject *swig_obj[1] ;
19274
19275 if (!args) SWIG_fail;
19276 swig_obj[0] = args;
19277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19278 if (!SWIG_IsOK(res1)) {
19279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19280 }
19281 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19282 {
19283 PyThreadState* __tstate = wxPyBeginAllowThreads();
19284 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 resultobj = SWIG_From_long(static_cast< long >(result));
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19296 PyObject *resultobj = 0;
19297 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19298 int arg2 ;
19299 void *argp1 = 0 ;
19300 int res1 = 0 ;
19301 int val2 ;
19302 int ecode2 = 0 ;
19303 PyObject * obj0 = 0 ;
19304 PyObject * obj1 = 0 ;
19305 char * kwnames[] = {
19306 (char *) "self",(char *) "i", NULL
19307 };
19308
19309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19311 if (!SWIG_IsOK(res1)) {
19312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19313 }
19314 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19315 ecode2 = SWIG_AsVal_int(obj1, &val2);
19316 if (!SWIG_IsOK(ecode2)) {
19317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19318 }
19319 arg2 = static_cast< int >(val2);
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 (arg1)->SetInt(arg2);
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 resultobj = SWIG_Py_Void();
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19334 PyObject *resultobj = 0;
19335 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19336 int result;
19337 void *argp1 = 0 ;
19338 int res1 = 0 ;
19339 PyObject *swig_obj[1] ;
19340
19341 if (!args) SWIG_fail;
19342 swig_obj[0] = args;
19343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19344 if (!SWIG_IsOK(res1)) {
19345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19346 }
19347 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19348 {
19349 PyThreadState* __tstate = wxPyBeginAllowThreads();
19350 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19351 wxPyEndAllowThreads(__tstate);
19352 if (PyErr_Occurred()) SWIG_fail;
19353 }
19354 resultobj = SWIG_From_int(static_cast< int >(result));
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19362 PyObject *resultobj = 0;
19363 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19364 PyObject *result = 0 ;
19365 void *argp1 = 0 ;
19366 int res1 = 0 ;
19367 PyObject *swig_obj[1] ;
19368
19369 if (!args) SWIG_fail;
19370 swig_obj[0] = args;
19371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19372 if (!SWIG_IsOK(res1)) {
19373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19374 }
19375 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 resultobj = result;
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj = 0;
19391 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19392 PyObject *arg2 = (PyObject *) 0 ;
19393 void *argp1 = 0 ;
19394 int res1 = 0 ;
19395 PyObject * obj0 = 0 ;
19396 PyObject * obj1 = 0 ;
19397 char * kwnames[] = {
19398 (char *) "self",(char *) "clientData", NULL
19399 };
19400
19401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19403 if (!SWIG_IsOK(res1)) {
19404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19405 }
19406 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19407 arg2 = obj1;
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 wxCommandEvent_SetClientData(arg1,arg2);
19411 wxPyEndAllowThreads(__tstate);
19412 if (PyErr_Occurred()) SWIG_fail;
19413 }
19414 resultobj = SWIG_Py_Void();
19415 return resultobj;
19416 fail:
19417 return NULL;
19418 }
19419
19420
19421 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19422 PyObject *resultobj = 0;
19423 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19424 wxEvent *result = 0 ;
19425 void *argp1 = 0 ;
19426 int res1 = 0 ;
19427 PyObject *swig_obj[1] ;
19428
19429 if (!args) SWIG_fail;
19430 swig_obj[0] = args;
19431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19432 if (!SWIG_IsOK(res1)) {
19433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19434 }
19435 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19436 {
19437 PyThreadState* __tstate = wxPyBeginAllowThreads();
19438 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19439 wxPyEndAllowThreads(__tstate);
19440 if (PyErr_Occurred()) SWIG_fail;
19441 }
19442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19443 return resultobj;
19444 fail:
19445 return NULL;
19446 }
19447
19448
19449 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19450 PyObject *obj;
19451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19452 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19453 return SWIG_Py_Void();
19454 }
19455
19456 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19457 return SWIG_Python_InitShadowInstance(args);
19458 }
19459
19460 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj = 0;
19462 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19463 int arg2 = (int) 0 ;
19464 wxNotifyEvent *result = 0 ;
19465 int val1 ;
19466 int ecode1 = 0 ;
19467 int val2 ;
19468 int ecode2 = 0 ;
19469 PyObject * obj0 = 0 ;
19470 PyObject * obj1 = 0 ;
19471 char * kwnames[] = {
19472 (char *) "commandType",(char *) "winid", NULL
19473 };
19474
19475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19476 if (obj0) {
19477 ecode1 = SWIG_AsVal_int(obj0, &val1);
19478 if (!SWIG_IsOK(ecode1)) {
19479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19480 }
19481 arg1 = static_cast< wxEventType >(val1);
19482 }
19483 if (obj1) {
19484 ecode2 = SWIG_AsVal_int(obj1, &val2);
19485 if (!SWIG_IsOK(ecode2)) {
19486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19487 }
19488 arg2 = static_cast< int >(val2);
19489 }
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19504 PyObject *resultobj = 0;
19505 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19506 void *argp1 = 0 ;
19507 int res1 = 0 ;
19508 PyObject *swig_obj[1] ;
19509
19510 if (!args) SWIG_fail;
19511 swig_obj[0] = args;
19512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19513 if (!SWIG_IsOK(res1)) {
19514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19515 }
19516 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19517 {
19518 PyThreadState* __tstate = wxPyBeginAllowThreads();
19519 (arg1)->Veto();
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 resultobj = SWIG_Py_Void();
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19531 PyObject *resultobj = 0;
19532 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19533 void *argp1 = 0 ;
19534 int res1 = 0 ;
19535 PyObject *swig_obj[1] ;
19536
19537 if (!args) SWIG_fail;
19538 swig_obj[0] = args;
19539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19540 if (!SWIG_IsOK(res1)) {
19541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19542 }
19543 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19544 {
19545 PyThreadState* __tstate = wxPyBeginAllowThreads();
19546 (arg1)->Allow();
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 resultobj = SWIG_Py_Void();
19551 return resultobj;
19552 fail:
19553 return NULL;
19554 }
19555
19556
19557 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19558 PyObject *resultobj = 0;
19559 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19560 bool result;
19561 void *argp1 = 0 ;
19562 int res1 = 0 ;
19563 PyObject *swig_obj[1] ;
19564
19565 if (!args) SWIG_fail;
19566 swig_obj[0] = args;
19567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19568 if (!SWIG_IsOK(res1)) {
19569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19570 }
19571 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 result = (bool)(arg1)->IsAllowed();
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 {
19579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19580 }
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19588 PyObject *obj;
19589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19590 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19591 return SWIG_Py_Void();
19592 }
19593
19594 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19595 return SWIG_Python_InitShadowInstance(args);
19596 }
19597
19598 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19599 PyObject *resultobj = 0;
19600 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19601 int arg2 = (int) 0 ;
19602 int arg3 = (int) 0 ;
19603 int arg4 = (int) 0 ;
19604 wxScrollEvent *result = 0 ;
19605 int val1 ;
19606 int ecode1 = 0 ;
19607 int val2 ;
19608 int ecode2 = 0 ;
19609 int val3 ;
19610 int ecode3 = 0 ;
19611 int val4 ;
19612 int ecode4 = 0 ;
19613 PyObject * obj0 = 0 ;
19614 PyObject * obj1 = 0 ;
19615 PyObject * obj2 = 0 ;
19616 PyObject * obj3 = 0 ;
19617 char * kwnames[] = {
19618 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19619 };
19620
19621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19622 if (obj0) {
19623 ecode1 = SWIG_AsVal_int(obj0, &val1);
19624 if (!SWIG_IsOK(ecode1)) {
19625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19626 }
19627 arg1 = static_cast< wxEventType >(val1);
19628 }
19629 if (obj1) {
19630 ecode2 = SWIG_AsVal_int(obj1, &val2);
19631 if (!SWIG_IsOK(ecode2)) {
19632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19633 }
19634 arg2 = static_cast< int >(val2);
19635 }
19636 if (obj2) {
19637 ecode3 = SWIG_AsVal_int(obj2, &val3);
19638 if (!SWIG_IsOK(ecode3)) {
19639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19640 }
19641 arg3 = static_cast< int >(val3);
19642 }
19643 if (obj3) {
19644 ecode4 = SWIG_AsVal_int(obj3, &val4);
19645 if (!SWIG_IsOK(ecode4)) {
19646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19647 }
19648 arg4 = static_cast< int >(val4);
19649 }
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19664 PyObject *resultobj = 0;
19665 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19666 int result;
19667 void *argp1 = 0 ;
19668 int res1 = 0 ;
19669 PyObject *swig_obj[1] ;
19670
19671 if (!args) SWIG_fail;
19672 swig_obj[0] = args;
19673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19674 if (!SWIG_IsOK(res1)) {
19675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19676 }
19677 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19678 {
19679 PyThreadState* __tstate = wxPyBeginAllowThreads();
19680 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19681 wxPyEndAllowThreads(__tstate);
19682 if (PyErr_Occurred()) SWIG_fail;
19683 }
19684 resultobj = SWIG_From_int(static_cast< int >(result));
19685 return resultobj;
19686 fail:
19687 return NULL;
19688 }
19689
19690
19691 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19692 PyObject *resultobj = 0;
19693 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19694 int result;
19695 void *argp1 = 0 ;
19696 int res1 = 0 ;
19697 PyObject *swig_obj[1] ;
19698
19699 if (!args) SWIG_fail;
19700 swig_obj[0] = args;
19701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19702 if (!SWIG_IsOK(res1)) {
19703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19704 }
19705 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19706 {
19707 PyThreadState* __tstate = wxPyBeginAllowThreads();
19708 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19709 wxPyEndAllowThreads(__tstate);
19710 if (PyErr_Occurred()) SWIG_fail;
19711 }
19712 resultobj = SWIG_From_int(static_cast< int >(result));
19713 return resultobj;
19714 fail:
19715 return NULL;
19716 }
19717
19718
19719 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19720 PyObject *resultobj = 0;
19721 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19722 int arg2 ;
19723 void *argp1 = 0 ;
19724 int res1 = 0 ;
19725 int val2 ;
19726 int ecode2 = 0 ;
19727 PyObject * obj0 = 0 ;
19728 PyObject * obj1 = 0 ;
19729 char * kwnames[] = {
19730 (char *) "self",(char *) "orient", NULL
19731 };
19732
19733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19735 if (!SWIG_IsOK(res1)) {
19736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19737 }
19738 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19739 ecode2 = SWIG_AsVal_int(obj1, &val2);
19740 if (!SWIG_IsOK(ecode2)) {
19741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19742 }
19743 arg2 = static_cast< int >(val2);
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 (arg1)->SetOrientation(arg2);
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 resultobj = SWIG_Py_Void();
19751 return resultobj;
19752 fail:
19753 return NULL;
19754 }
19755
19756
19757 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19758 PyObject *resultobj = 0;
19759 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19760 int arg2 ;
19761 void *argp1 = 0 ;
19762 int res1 = 0 ;
19763 int val2 ;
19764 int ecode2 = 0 ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "self",(char *) "pos", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19773 if (!SWIG_IsOK(res1)) {
19774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19775 }
19776 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19777 ecode2 = SWIG_AsVal_int(obj1, &val2);
19778 if (!SWIG_IsOK(ecode2)) {
19779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19780 }
19781 arg2 = static_cast< int >(val2);
19782 {
19783 PyThreadState* __tstate = wxPyBeginAllowThreads();
19784 (arg1)->SetPosition(arg2);
19785 wxPyEndAllowThreads(__tstate);
19786 if (PyErr_Occurred()) SWIG_fail;
19787 }
19788 resultobj = SWIG_Py_Void();
19789 return resultobj;
19790 fail:
19791 return NULL;
19792 }
19793
19794
19795 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19796 PyObject *obj;
19797 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19798 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19799 return SWIG_Py_Void();
19800 }
19801
19802 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19803 return SWIG_Python_InitShadowInstance(args);
19804 }
19805
19806 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj = 0;
19808 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19809 int arg2 = (int) 0 ;
19810 int arg3 = (int) 0 ;
19811 wxScrollWinEvent *result = 0 ;
19812 int val1 ;
19813 int ecode1 = 0 ;
19814 int val2 ;
19815 int ecode2 = 0 ;
19816 int val3 ;
19817 int ecode3 = 0 ;
19818 PyObject * obj0 = 0 ;
19819 PyObject * obj1 = 0 ;
19820 PyObject * obj2 = 0 ;
19821 char * kwnames[] = {
19822 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19823 };
19824
19825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19826 if (obj0) {
19827 ecode1 = SWIG_AsVal_int(obj0, &val1);
19828 if (!SWIG_IsOK(ecode1)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19830 }
19831 arg1 = static_cast< wxEventType >(val1);
19832 }
19833 if (obj1) {
19834 ecode2 = SWIG_AsVal_int(obj1, &val2);
19835 if (!SWIG_IsOK(ecode2)) {
19836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19837 }
19838 arg2 = static_cast< int >(val2);
19839 }
19840 if (obj2) {
19841 ecode3 = SWIG_AsVal_int(obj2, &val3);
19842 if (!SWIG_IsOK(ecode3)) {
19843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19844 }
19845 arg3 = static_cast< int >(val3);
19846 }
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19861 PyObject *resultobj = 0;
19862 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19863 int result;
19864 void *argp1 = 0 ;
19865 int res1 = 0 ;
19866 PyObject *swig_obj[1] ;
19867
19868 if (!args) SWIG_fail;
19869 swig_obj[0] = args;
19870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19871 if (!SWIG_IsOK(res1)) {
19872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19873 }
19874 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19875 {
19876 PyThreadState* __tstate = wxPyBeginAllowThreads();
19877 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19878 wxPyEndAllowThreads(__tstate);
19879 if (PyErr_Occurred()) SWIG_fail;
19880 }
19881 resultobj = SWIG_From_int(static_cast< int >(result));
19882 return resultobj;
19883 fail:
19884 return NULL;
19885 }
19886
19887
19888 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19889 PyObject *resultobj = 0;
19890 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19891 int result;
19892 void *argp1 = 0 ;
19893 int res1 = 0 ;
19894 PyObject *swig_obj[1] ;
19895
19896 if (!args) SWIG_fail;
19897 swig_obj[0] = args;
19898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19899 if (!SWIG_IsOK(res1)) {
19900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19901 }
19902 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19903 {
19904 PyThreadState* __tstate = wxPyBeginAllowThreads();
19905 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19906 wxPyEndAllowThreads(__tstate);
19907 if (PyErr_Occurred()) SWIG_fail;
19908 }
19909 resultobj = SWIG_From_int(static_cast< int >(result));
19910 return resultobj;
19911 fail:
19912 return NULL;
19913 }
19914
19915
19916 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19917 PyObject *resultobj = 0;
19918 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19919 int arg2 ;
19920 void *argp1 = 0 ;
19921 int res1 = 0 ;
19922 int val2 ;
19923 int ecode2 = 0 ;
19924 PyObject * obj0 = 0 ;
19925 PyObject * obj1 = 0 ;
19926 char * kwnames[] = {
19927 (char *) "self",(char *) "orient", NULL
19928 };
19929
19930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19932 if (!SWIG_IsOK(res1)) {
19933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19934 }
19935 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19936 ecode2 = SWIG_AsVal_int(obj1, &val2);
19937 if (!SWIG_IsOK(ecode2)) {
19938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19939 }
19940 arg2 = static_cast< int >(val2);
19941 {
19942 PyThreadState* __tstate = wxPyBeginAllowThreads();
19943 (arg1)->SetOrientation(arg2);
19944 wxPyEndAllowThreads(__tstate);
19945 if (PyErr_Occurred()) SWIG_fail;
19946 }
19947 resultobj = SWIG_Py_Void();
19948 return resultobj;
19949 fail:
19950 return NULL;
19951 }
19952
19953
19954 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19955 PyObject *resultobj = 0;
19956 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19957 int arg2 ;
19958 void *argp1 = 0 ;
19959 int res1 = 0 ;
19960 int val2 ;
19961 int ecode2 = 0 ;
19962 PyObject * obj0 = 0 ;
19963 PyObject * obj1 = 0 ;
19964 char * kwnames[] = {
19965 (char *) "self",(char *) "pos", NULL
19966 };
19967
19968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19970 if (!SWIG_IsOK(res1)) {
19971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19972 }
19973 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19974 ecode2 = SWIG_AsVal_int(obj1, &val2);
19975 if (!SWIG_IsOK(ecode2)) {
19976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19977 }
19978 arg2 = static_cast< int >(val2);
19979 {
19980 PyThreadState* __tstate = wxPyBeginAllowThreads();
19981 (arg1)->SetPosition(arg2);
19982 wxPyEndAllowThreads(__tstate);
19983 if (PyErr_Occurred()) SWIG_fail;
19984 }
19985 resultobj = SWIG_Py_Void();
19986 return resultobj;
19987 fail:
19988 return NULL;
19989 }
19990
19991
19992 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19993 PyObject *obj;
19994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19995 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19996 return SWIG_Py_Void();
19997 }
19998
19999 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20000 return SWIG_Python_InitShadowInstance(args);
20001 }
20002
20003 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20004 PyObject *resultobj = 0;
20005 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20006 wxMouseEvent *result = 0 ;
20007 int val1 ;
20008 int ecode1 = 0 ;
20009 PyObject * obj0 = 0 ;
20010 char * kwnames[] = {
20011 (char *) "mouseType", NULL
20012 };
20013
20014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20015 if (obj0) {
20016 ecode1 = SWIG_AsVal_int(obj0, &val1);
20017 if (!SWIG_IsOK(ecode1)) {
20018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20019 }
20020 arg1 = static_cast< wxEventType >(val1);
20021 }
20022 {
20023 PyThreadState* __tstate = wxPyBeginAllowThreads();
20024 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20025 wxPyEndAllowThreads(__tstate);
20026 if (PyErr_Occurred()) SWIG_fail;
20027 }
20028 {
20029 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20030 }
20031 return resultobj;
20032 fail:
20033 return NULL;
20034 }
20035
20036
20037 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20038 PyObject *resultobj = 0;
20039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20040 bool result;
20041 void *argp1 = 0 ;
20042 int res1 = 0 ;
20043 PyObject *swig_obj[1] ;
20044
20045 if (!args) SWIG_fail;
20046 swig_obj[0] = args;
20047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20048 if (!SWIG_IsOK(res1)) {
20049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20050 }
20051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20052 {
20053 PyThreadState* __tstate = wxPyBeginAllowThreads();
20054 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20055 wxPyEndAllowThreads(__tstate);
20056 if (PyErr_Occurred()) SWIG_fail;
20057 }
20058 {
20059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20060 }
20061 return resultobj;
20062 fail:
20063 return NULL;
20064 }
20065
20066
20067 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj = 0;
20069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20070 int arg2 = (int) wxMOUSE_BTN_ANY ;
20071 bool result;
20072 void *argp1 = 0 ;
20073 int res1 = 0 ;
20074 int val2 ;
20075 int ecode2 = 0 ;
20076 PyObject * obj0 = 0 ;
20077 PyObject * obj1 = 0 ;
20078 char * kwnames[] = {
20079 (char *) "self",(char *) "but", NULL
20080 };
20081
20082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20084 if (!SWIG_IsOK(res1)) {
20085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20086 }
20087 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20088 if (obj1) {
20089 ecode2 = SWIG_AsVal_int(obj1, &val2);
20090 if (!SWIG_IsOK(ecode2)) {
20091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20092 }
20093 arg2 = static_cast< int >(val2);
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20098 wxPyEndAllowThreads(__tstate);
20099 if (PyErr_Occurred()) SWIG_fail;
20100 }
20101 {
20102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20103 }
20104 return resultobj;
20105 fail:
20106 return NULL;
20107 }
20108
20109
20110 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20111 PyObject *resultobj = 0;
20112 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20113 int arg2 = (int) wxMOUSE_BTN_ANY ;
20114 bool result;
20115 void *argp1 = 0 ;
20116 int res1 = 0 ;
20117 int val2 ;
20118 int ecode2 = 0 ;
20119 PyObject * obj0 = 0 ;
20120 PyObject * obj1 = 0 ;
20121 char * kwnames[] = {
20122 (char *) "self",(char *) "but", NULL
20123 };
20124
20125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20127 if (!SWIG_IsOK(res1)) {
20128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20129 }
20130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20131 if (obj1) {
20132 ecode2 = SWIG_AsVal_int(obj1, &val2);
20133 if (!SWIG_IsOK(ecode2)) {
20134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20135 }
20136 arg2 = static_cast< int >(val2);
20137 }
20138 {
20139 PyThreadState* __tstate = wxPyBeginAllowThreads();
20140 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20141 wxPyEndAllowThreads(__tstate);
20142 if (PyErr_Occurred()) SWIG_fail;
20143 }
20144 {
20145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20146 }
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20154 PyObject *resultobj = 0;
20155 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20156 int arg2 = (int) wxMOUSE_BTN_ANY ;
20157 bool result;
20158 void *argp1 = 0 ;
20159 int res1 = 0 ;
20160 int val2 ;
20161 int ecode2 = 0 ;
20162 PyObject * obj0 = 0 ;
20163 PyObject * obj1 = 0 ;
20164 char * kwnames[] = {
20165 (char *) "self",(char *) "but", NULL
20166 };
20167
20168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20170 if (!SWIG_IsOK(res1)) {
20171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20172 }
20173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20174 if (obj1) {
20175 ecode2 = SWIG_AsVal_int(obj1, &val2);
20176 if (!SWIG_IsOK(ecode2)) {
20177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20178 }
20179 arg2 = static_cast< int >(val2);
20180 }
20181 {
20182 PyThreadState* __tstate = wxPyBeginAllowThreads();
20183 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20184 wxPyEndAllowThreads(__tstate);
20185 if (PyErr_Occurred()) SWIG_fail;
20186 }
20187 {
20188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20189 }
20190 return resultobj;
20191 fail:
20192 return NULL;
20193 }
20194
20195
20196 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20197 PyObject *resultobj = 0;
20198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20199 int arg2 ;
20200 bool result;
20201 void *argp1 = 0 ;
20202 int res1 = 0 ;
20203 int val2 ;
20204 int ecode2 = 0 ;
20205 PyObject * obj0 = 0 ;
20206 PyObject * obj1 = 0 ;
20207 char * kwnames[] = {
20208 (char *) "self",(char *) "button", NULL
20209 };
20210
20211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20213 if (!SWIG_IsOK(res1)) {
20214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20215 }
20216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20217 ecode2 = SWIG_AsVal_int(obj1, &val2);
20218 if (!SWIG_IsOK(ecode2)) {
20219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20220 }
20221 arg2 = static_cast< int >(val2);
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 {
20229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20230 }
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20238 PyObject *resultobj = 0;
20239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20240 int arg2 ;
20241 bool result;
20242 void *argp1 = 0 ;
20243 int res1 = 0 ;
20244 int val2 ;
20245 int ecode2 = 0 ;
20246 PyObject * obj0 = 0 ;
20247 PyObject * obj1 = 0 ;
20248 char * kwnames[] = {
20249 (char *) "self",(char *) "but", NULL
20250 };
20251
20252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20254 if (!SWIG_IsOK(res1)) {
20255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20256 }
20257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20258 ecode2 = SWIG_AsVal_int(obj1, &val2);
20259 if (!SWIG_IsOK(ecode2)) {
20260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20261 }
20262 arg2 = static_cast< int >(val2);
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 {
20270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20271 }
20272 return resultobj;
20273 fail:
20274 return NULL;
20275 }
20276
20277
20278 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20279 PyObject *resultobj = 0;
20280 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20281 int result;
20282 void *argp1 = 0 ;
20283 int res1 = 0 ;
20284 PyObject *swig_obj[1] ;
20285
20286 if (!args) SWIG_fail;
20287 swig_obj[0] = args;
20288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20289 if (!SWIG_IsOK(res1)) {
20290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20291 }
20292 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20296 wxPyEndAllowThreads(__tstate);
20297 if (PyErr_Occurred()) SWIG_fail;
20298 }
20299 resultobj = SWIG_From_int(static_cast< int >(result));
20300 return resultobj;
20301 fail:
20302 return NULL;
20303 }
20304
20305
20306 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20307 PyObject *resultobj = 0;
20308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20309 bool result;
20310 void *argp1 = 0 ;
20311 int res1 = 0 ;
20312 PyObject *swig_obj[1] ;
20313
20314 if (!args) SWIG_fail;
20315 swig_obj[0] = args;
20316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20317 if (!SWIG_IsOK(res1)) {
20318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20319 }
20320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 {
20328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20329 }
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20337 PyObject *resultobj = 0;
20338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20339 bool result;
20340 void *argp1 = 0 ;
20341 int res1 = 0 ;
20342 PyObject *swig_obj[1] ;
20343
20344 if (!args) SWIG_fail;
20345 swig_obj[0] = args;
20346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20347 if (!SWIG_IsOK(res1)) {
20348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20349 }
20350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20359 }
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20367 PyObject *resultobj = 0;
20368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20369 bool result;
20370 void *argp1 = 0 ;
20371 int res1 = 0 ;
20372 PyObject *swig_obj[1] ;
20373
20374 if (!args) SWIG_fail;
20375 swig_obj[0] = args;
20376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20377 if (!SWIG_IsOK(res1)) {
20378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20379 }
20380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20381 {
20382 PyThreadState* __tstate = wxPyBeginAllowThreads();
20383 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 {
20388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20389 }
20390 return resultobj;
20391 fail:
20392 return NULL;
20393 }
20394
20395
20396 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20397 PyObject *resultobj = 0;
20398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20399 bool result;
20400 void *argp1 = 0 ;
20401 int res1 = 0 ;
20402 PyObject *swig_obj[1] ;
20403
20404 if (!args) SWIG_fail;
20405 swig_obj[0] = args;
20406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20407 if (!SWIG_IsOK(res1)) {
20408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20409 }
20410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 {
20418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20419 }
20420 return resultobj;
20421 fail:
20422 return NULL;
20423 }
20424
20425
20426 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20427 PyObject *resultobj = 0;
20428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20429 bool result;
20430 void *argp1 = 0 ;
20431 int res1 = 0 ;
20432 PyObject *swig_obj[1] ;
20433
20434 if (!args) SWIG_fail;
20435 swig_obj[0] = args;
20436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20437 if (!SWIG_IsOK(res1)) {
20438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20439 }
20440 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20449 }
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20459 bool result;
20460 void *argp1 = 0 ;
20461 int res1 = 0 ;
20462 PyObject *swig_obj[1] ;
20463
20464 if (!args) SWIG_fail;
20465 swig_obj[0] = args;
20466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20467 if (!SWIG_IsOK(res1)) {
20468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20469 }
20470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20479 }
20480 return resultobj;
20481 fail:
20482 return NULL;
20483 }
20484
20485
20486 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20487 PyObject *resultobj = 0;
20488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20489 bool result;
20490 void *argp1 = 0 ;
20491 int res1 = 0 ;
20492 PyObject *swig_obj[1] ;
20493
20494 if (!args) SWIG_fail;
20495 swig_obj[0] = args;
20496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20497 if (!SWIG_IsOK(res1)) {
20498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20499 }
20500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20504 wxPyEndAllowThreads(__tstate);
20505 if (PyErr_Occurred()) SWIG_fail;
20506 }
20507 {
20508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20509 }
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20517 PyObject *resultobj = 0;
20518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20519 bool result;
20520 void *argp1 = 0 ;
20521 int res1 = 0 ;
20522 PyObject *swig_obj[1] ;
20523
20524 if (!args) SWIG_fail;
20525 swig_obj[0] = args;
20526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20527 if (!SWIG_IsOK(res1)) {
20528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20529 }
20530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 {
20538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20539 }
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20547 PyObject *resultobj = 0;
20548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20549 bool result;
20550 void *argp1 = 0 ;
20551 int res1 = 0 ;
20552 PyObject *swig_obj[1] ;
20553
20554 if (!args) SWIG_fail;
20555 swig_obj[0] = args;
20556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20559 }
20560 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 {
20568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20569 }
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20577 PyObject *resultobj = 0;
20578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20579 bool result;
20580 void *argp1 = 0 ;
20581 int res1 = 0 ;
20582 PyObject *swig_obj[1] ;
20583
20584 if (!args) SWIG_fail;
20585 swig_obj[0] = args;
20586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20587 if (!SWIG_IsOK(res1)) {
20588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20589 }
20590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 {
20598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20599 }
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20607 PyObject *resultobj = 0;
20608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20609 bool result;
20610 void *argp1 = 0 ;
20611 int res1 = 0 ;
20612 PyObject *swig_obj[1] ;
20613
20614 if (!args) SWIG_fail;
20615 swig_obj[0] = args;
20616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20617 if (!SWIG_IsOK(res1)) {
20618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20619 }
20620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20621 {
20622 PyThreadState* __tstate = wxPyBeginAllowThreads();
20623 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20624 wxPyEndAllowThreads(__tstate);
20625 if (PyErr_Occurred()) SWIG_fail;
20626 }
20627 {
20628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20629 }
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20637 PyObject *resultobj = 0;
20638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20639 bool result;
20640 void *argp1 = 0 ;
20641 int res1 = 0 ;
20642 PyObject *swig_obj[1] ;
20643
20644 if (!args) SWIG_fail;
20645 swig_obj[0] = args;
20646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20649 }
20650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20651 {
20652 PyThreadState* __tstate = wxPyBeginAllowThreads();
20653 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 {
20658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20659 }
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20667 PyObject *resultobj = 0;
20668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20669 bool result;
20670 void *argp1 = 0 ;
20671 int res1 = 0 ;
20672 PyObject *swig_obj[1] ;
20673
20674 if (!args) SWIG_fail;
20675 swig_obj[0] = args;
20676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20677 if (!SWIG_IsOK(res1)) {
20678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20679 }
20680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20684 wxPyEndAllowThreads(__tstate);
20685 if (PyErr_Occurred()) SWIG_fail;
20686 }
20687 {
20688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20689 }
20690 return resultobj;
20691 fail:
20692 return NULL;
20693 }
20694
20695
20696 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20697 PyObject *resultobj = 0;
20698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20699 bool result;
20700 void *argp1 = 0 ;
20701 int res1 = 0 ;
20702 PyObject *swig_obj[1] ;
20703
20704 if (!args) SWIG_fail;
20705 swig_obj[0] = args;
20706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20707 if (!SWIG_IsOK(res1)) {
20708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20709 }
20710 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20719 }
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20727 PyObject *resultobj = 0;
20728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20729 bool result;
20730 void *argp1 = 0 ;
20731 int res1 = 0 ;
20732 PyObject *swig_obj[1] ;
20733
20734 if (!args) SWIG_fail;
20735 swig_obj[0] = args;
20736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20739 }
20740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 result = (bool)(arg1)->LeftIsDown();
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 {
20748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20749 }
20750 return resultobj;
20751 fail:
20752 return NULL;
20753 }
20754
20755
20756 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20757 PyObject *resultobj = 0;
20758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20759 bool result;
20760 void *argp1 = 0 ;
20761 int res1 = 0 ;
20762 PyObject *swig_obj[1] ;
20763
20764 if (!args) SWIG_fail;
20765 swig_obj[0] = args;
20766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20767 if (!SWIG_IsOK(res1)) {
20768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20769 }
20770 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (bool)(arg1)->MiddleIsDown();
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 {
20778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20779 }
20780 return resultobj;
20781 fail:
20782 return NULL;
20783 }
20784
20785
20786 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20787 PyObject *resultobj = 0;
20788 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20789 bool result;
20790 void *argp1 = 0 ;
20791 int res1 = 0 ;
20792 PyObject *swig_obj[1] ;
20793
20794 if (!args) SWIG_fail;
20795 swig_obj[0] = args;
20796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20797 if (!SWIG_IsOK(res1)) {
20798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20799 }
20800 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20801 {
20802 PyThreadState* __tstate = wxPyBeginAllowThreads();
20803 result = (bool)(arg1)->RightIsDown();
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 {
20808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20817 PyObject *resultobj = 0;
20818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20819 bool result;
20820 void *argp1 = 0 ;
20821 int res1 = 0 ;
20822 PyObject *swig_obj[1] ;
20823
20824 if (!args) SWIG_fail;
20825 swig_obj[0] = args;
20826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20827 if (!SWIG_IsOK(res1)) {
20828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20829 }
20830 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20831 {
20832 PyThreadState* __tstate = wxPyBeginAllowThreads();
20833 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 {
20838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20839 }
20840 return resultobj;
20841 fail:
20842 return NULL;
20843 }
20844
20845
20846 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20847 PyObject *resultobj = 0;
20848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20849 bool result;
20850 void *argp1 = 0 ;
20851 int res1 = 0 ;
20852 PyObject *swig_obj[1] ;
20853
20854 if (!args) SWIG_fail;
20855 swig_obj[0] = args;
20856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20857 if (!SWIG_IsOK(res1)) {
20858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20859 }
20860 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20861 {
20862 PyThreadState* __tstate = wxPyBeginAllowThreads();
20863 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 {
20868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20869 }
20870 return resultobj;
20871 fail:
20872 return NULL;
20873 }
20874
20875
20876 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20877 PyObject *resultobj = 0;
20878 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20879 bool result;
20880 void *argp1 = 0 ;
20881 int res1 = 0 ;
20882 PyObject *swig_obj[1] ;
20883
20884 if (!args) SWIG_fail;
20885 swig_obj[0] = args;
20886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20887 if (!SWIG_IsOK(res1)) {
20888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20889 }
20890 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20891 {
20892 PyThreadState* __tstate = wxPyBeginAllowThreads();
20893 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20894 wxPyEndAllowThreads(__tstate);
20895 if (PyErr_Occurred()) SWIG_fail;
20896 }
20897 {
20898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20899 }
20900 return resultobj;
20901 fail:
20902 return NULL;
20903 }
20904
20905
20906 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20907 PyObject *resultobj = 0;
20908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20909 bool result;
20910 void *argp1 = 0 ;
20911 int res1 = 0 ;
20912 PyObject *swig_obj[1] ;
20913
20914 if (!args) SWIG_fail;
20915 swig_obj[0] = args;
20916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20917 if (!SWIG_IsOK(res1)) {
20918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20919 }
20920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 {
20928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20929 }
20930 return resultobj;
20931 fail:
20932 return NULL;
20933 }
20934
20935
20936 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20937 PyObject *resultobj = 0;
20938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20939 wxPoint result;
20940 void *argp1 = 0 ;
20941 int res1 = 0 ;
20942 PyObject *swig_obj[1] ;
20943
20944 if (!args) SWIG_fail;
20945 swig_obj[0] = args;
20946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20947 if (!SWIG_IsOK(res1)) {
20948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20949 }
20950 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 result = (arg1)->GetPosition();
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20965 PyObject *resultobj = 0;
20966 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20967 long *arg2 = (long *) 0 ;
20968 long *arg3 = (long *) 0 ;
20969 void *argp1 = 0 ;
20970 int res1 = 0 ;
20971 long temp2 ;
20972 int res2 = SWIG_TMPOBJ ;
20973 long temp3 ;
20974 int res3 = SWIG_TMPOBJ ;
20975 PyObject *swig_obj[1] ;
20976
20977 arg2 = &temp2;
20978 arg3 = &temp3;
20979 if (!args) SWIG_fail;
20980 swig_obj[0] = args;
20981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20982 if (!SWIG_IsOK(res1)) {
20983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20984 }
20985 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 (arg1)->GetPosition(arg2,arg3);
20989 wxPyEndAllowThreads(__tstate);
20990 if (PyErr_Occurred()) SWIG_fail;
20991 }
20992 resultobj = SWIG_Py_Void();
20993 if (SWIG_IsTmpObj(res2)) {
20994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20995 } else {
20996 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20998 }
20999 if (SWIG_IsTmpObj(res3)) {
21000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21001 } else {
21002 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21004 }
21005 return resultobj;
21006 fail:
21007 return NULL;
21008 }
21009
21010
21011 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21012 PyObject *resultobj = 0;
21013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21014 wxDC *arg2 = 0 ;
21015 wxPoint result;
21016 void *argp1 = 0 ;
21017 int res1 = 0 ;
21018 void *argp2 = 0 ;
21019 int res2 = 0 ;
21020 PyObject * obj0 = 0 ;
21021 PyObject * obj1 = 0 ;
21022 char * kwnames[] = {
21023 (char *) "self",(char *) "dc", NULL
21024 };
21025
21026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21028 if (!SWIG_IsOK(res1)) {
21029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21030 }
21031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21033 if (!SWIG_IsOK(res2)) {
21034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21035 }
21036 if (!argp2) {
21037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21038 }
21039 arg2 = reinterpret_cast< wxDC * >(argp2);
21040 {
21041 PyThreadState* __tstate = wxPyBeginAllowThreads();
21042 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21043 wxPyEndAllowThreads(__tstate);
21044 if (PyErr_Occurred()) SWIG_fail;
21045 }
21046 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21047 return resultobj;
21048 fail:
21049 return NULL;
21050 }
21051
21052
21053 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21054 PyObject *resultobj = 0;
21055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21056 int result;
21057 void *argp1 = 0 ;
21058 int res1 = 0 ;
21059 PyObject *swig_obj[1] ;
21060
21061 if (!args) SWIG_fail;
21062 swig_obj[0] = args;
21063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21064 if (!SWIG_IsOK(res1)) {
21065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21066 }
21067 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = (int)((wxMouseEvent const *)arg1)->GetX();
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 resultobj = SWIG_From_int(static_cast< int >(result));
21075 return resultobj;
21076 fail:
21077 return NULL;
21078 }
21079
21080
21081 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 PyObject *resultobj = 0;
21083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21084 int result;
21085 void *argp1 = 0 ;
21086 int res1 = 0 ;
21087 PyObject *swig_obj[1] ;
21088
21089 if (!args) SWIG_fail;
21090 swig_obj[0] = args;
21091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21092 if (!SWIG_IsOK(res1)) {
21093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21094 }
21095 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21096 {
21097 PyThreadState* __tstate = wxPyBeginAllowThreads();
21098 result = (int)((wxMouseEvent const *)arg1)->GetY();
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 resultobj = SWIG_From_int(static_cast< int >(result));
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21110 PyObject *resultobj = 0;
21111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21112 int result;
21113 void *argp1 = 0 ;
21114 int res1 = 0 ;
21115 PyObject *swig_obj[1] ;
21116
21117 if (!args) SWIG_fail;
21118 swig_obj[0] = args;
21119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21120 if (!SWIG_IsOK(res1)) {
21121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21122 }
21123 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21127 wxPyEndAllowThreads(__tstate);
21128 if (PyErr_Occurred()) SWIG_fail;
21129 }
21130 resultobj = SWIG_From_int(static_cast< int >(result));
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21138 PyObject *resultobj = 0;
21139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21140 int result;
21141 void *argp1 = 0 ;
21142 int res1 = 0 ;
21143 PyObject *swig_obj[1] ;
21144
21145 if (!args) SWIG_fail;
21146 swig_obj[0] = args;
21147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21148 if (!SWIG_IsOK(res1)) {
21149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21150 }
21151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 resultobj = SWIG_From_int(static_cast< int >(result));
21159 return resultobj;
21160 fail:
21161 return NULL;
21162 }
21163
21164
21165 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21166 PyObject *resultobj = 0;
21167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21168 int result;
21169 void *argp1 = 0 ;
21170 int res1 = 0 ;
21171 PyObject *swig_obj[1] ;
21172
21173 if (!args) SWIG_fail;
21174 swig_obj[0] = args;
21175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21176 if (!SWIG_IsOK(res1)) {
21177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21178 }
21179 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21183 wxPyEndAllowThreads(__tstate);
21184 if (PyErr_Occurred()) SWIG_fail;
21185 }
21186 resultobj = SWIG_From_int(static_cast< int >(result));
21187 return resultobj;
21188 fail:
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21194 PyObject *resultobj = 0;
21195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21196 bool result;
21197 void *argp1 = 0 ;
21198 int res1 = 0 ;
21199 PyObject *swig_obj[1] ;
21200
21201 if (!args) SWIG_fail;
21202 swig_obj[0] = args;
21203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21204 if (!SWIG_IsOK(res1)) {
21205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21206 }
21207 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 {
21215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21216 }
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21224 PyObject *resultobj = 0;
21225 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21226 int arg2 ;
21227 void *argp1 = 0 ;
21228 int res1 = 0 ;
21229 int val2 ;
21230 int ecode2 = 0 ;
21231 PyObject *swig_obj[2] ;
21232
21233 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21235 if (!SWIG_IsOK(res1)) {
21236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21237 }
21238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21239 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21240 if (!SWIG_IsOK(ecode2)) {
21241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21242 }
21243 arg2 = static_cast< int >(val2);
21244 if (arg1) (arg1)->m_x = arg2;
21245
21246 resultobj = SWIG_Py_Void();
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21254 PyObject *resultobj = 0;
21255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21256 int result;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 PyObject *swig_obj[1] ;
21260
21261 if (!args) SWIG_fail;
21262 swig_obj[0] = args;
21263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21264 if (!SWIG_IsOK(res1)) {
21265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21266 }
21267 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21268 result = (int) ((arg1)->m_x);
21269 resultobj = SWIG_From_int(static_cast< int >(result));
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21277 PyObject *resultobj = 0;
21278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21279 int arg2 ;
21280 void *argp1 = 0 ;
21281 int res1 = 0 ;
21282 int val2 ;
21283 int ecode2 = 0 ;
21284 PyObject *swig_obj[2] ;
21285
21286 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21288 if (!SWIG_IsOK(res1)) {
21289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21290 }
21291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21292 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21293 if (!SWIG_IsOK(ecode2)) {
21294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21295 }
21296 arg2 = static_cast< int >(val2);
21297 if (arg1) (arg1)->m_y = arg2;
21298
21299 resultobj = SWIG_Py_Void();
21300 return resultobj;
21301 fail:
21302 return NULL;
21303 }
21304
21305
21306 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21307 PyObject *resultobj = 0;
21308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21309 int result;
21310 void *argp1 = 0 ;
21311 int res1 = 0 ;
21312 PyObject *swig_obj[1] ;
21313
21314 if (!args) SWIG_fail;
21315 swig_obj[0] = args;
21316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21317 if (!SWIG_IsOK(res1)) {
21318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21319 }
21320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21321 result = (int) ((arg1)->m_y);
21322 resultobj = SWIG_From_int(static_cast< int >(result));
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21330 PyObject *resultobj = 0;
21331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21332 bool arg2 ;
21333 void *argp1 = 0 ;
21334 int res1 = 0 ;
21335 bool val2 ;
21336 int ecode2 = 0 ;
21337 PyObject *swig_obj[2] ;
21338
21339 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21341 if (!SWIG_IsOK(res1)) {
21342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21343 }
21344 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21345 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21346 if (!SWIG_IsOK(ecode2)) {
21347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21348 }
21349 arg2 = static_cast< bool >(val2);
21350 if (arg1) (arg1)->m_leftDown = arg2;
21351
21352 resultobj = SWIG_Py_Void();
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21360 PyObject *resultobj = 0;
21361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21362 bool result;
21363 void *argp1 = 0 ;
21364 int res1 = 0 ;
21365 PyObject *swig_obj[1] ;
21366
21367 if (!args) SWIG_fail;
21368 swig_obj[0] = args;
21369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21370 if (!SWIG_IsOK(res1)) {
21371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21372 }
21373 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21374 result = (bool) ((arg1)->m_leftDown);
21375 {
21376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21377 }
21378 return resultobj;
21379 fail:
21380 return NULL;
21381 }
21382
21383
21384 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21385 PyObject *resultobj = 0;
21386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21387 bool arg2 ;
21388 void *argp1 = 0 ;
21389 int res1 = 0 ;
21390 bool val2 ;
21391 int ecode2 = 0 ;
21392 PyObject *swig_obj[2] ;
21393
21394 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21396 if (!SWIG_IsOK(res1)) {
21397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21398 }
21399 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21400 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21401 if (!SWIG_IsOK(ecode2)) {
21402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21403 }
21404 arg2 = static_cast< bool >(val2);
21405 if (arg1) (arg1)->m_middleDown = arg2;
21406
21407 resultobj = SWIG_Py_Void();
21408 return resultobj;
21409 fail:
21410 return NULL;
21411 }
21412
21413
21414 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21415 PyObject *resultobj = 0;
21416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21417 bool result;
21418 void *argp1 = 0 ;
21419 int res1 = 0 ;
21420 PyObject *swig_obj[1] ;
21421
21422 if (!args) SWIG_fail;
21423 swig_obj[0] = args;
21424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21425 if (!SWIG_IsOK(res1)) {
21426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21427 }
21428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21429 result = (bool) ((arg1)->m_middleDown);
21430 {
21431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21432 }
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21440 PyObject *resultobj = 0;
21441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21442 bool arg2 ;
21443 void *argp1 = 0 ;
21444 int res1 = 0 ;
21445 bool val2 ;
21446 int ecode2 = 0 ;
21447 PyObject *swig_obj[2] ;
21448
21449 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21451 if (!SWIG_IsOK(res1)) {
21452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21453 }
21454 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21455 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21456 if (!SWIG_IsOK(ecode2)) {
21457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21458 }
21459 arg2 = static_cast< bool >(val2);
21460 if (arg1) (arg1)->m_rightDown = arg2;
21461
21462 resultobj = SWIG_Py_Void();
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21470 PyObject *resultobj = 0;
21471 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21472 bool result;
21473 void *argp1 = 0 ;
21474 int res1 = 0 ;
21475 PyObject *swig_obj[1] ;
21476
21477 if (!args) SWIG_fail;
21478 swig_obj[0] = args;
21479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21480 if (!SWIG_IsOK(res1)) {
21481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21482 }
21483 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21484 result = (bool) ((arg1)->m_rightDown);
21485 {
21486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21487 }
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21495 PyObject *resultobj = 0;
21496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21497 bool arg2 ;
21498 void *argp1 = 0 ;
21499 int res1 = 0 ;
21500 bool val2 ;
21501 int ecode2 = 0 ;
21502 PyObject *swig_obj[2] ;
21503
21504 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21506 if (!SWIG_IsOK(res1)) {
21507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21508 }
21509 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21510 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21511 if (!SWIG_IsOK(ecode2)) {
21512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21513 }
21514 arg2 = static_cast< bool >(val2);
21515 if (arg1) (arg1)->m_controlDown = arg2;
21516
21517 resultobj = SWIG_Py_Void();
21518 return resultobj;
21519 fail:
21520 return NULL;
21521 }
21522
21523
21524 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21525 PyObject *resultobj = 0;
21526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21527 bool result;
21528 void *argp1 = 0 ;
21529 int res1 = 0 ;
21530 PyObject *swig_obj[1] ;
21531
21532 if (!args) SWIG_fail;
21533 swig_obj[0] = args;
21534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21537 }
21538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21539 result = (bool) ((arg1)->m_controlDown);
21540 {
21541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21542 }
21543 return resultobj;
21544 fail:
21545 return NULL;
21546 }
21547
21548
21549 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21550 PyObject *resultobj = 0;
21551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21552 bool arg2 ;
21553 void *argp1 = 0 ;
21554 int res1 = 0 ;
21555 bool val2 ;
21556 int ecode2 = 0 ;
21557 PyObject *swig_obj[2] ;
21558
21559 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21561 if (!SWIG_IsOK(res1)) {
21562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21563 }
21564 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21565 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21566 if (!SWIG_IsOK(ecode2)) {
21567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21568 }
21569 arg2 = static_cast< bool >(val2);
21570 if (arg1) (arg1)->m_shiftDown = arg2;
21571
21572 resultobj = SWIG_Py_Void();
21573 return resultobj;
21574 fail:
21575 return NULL;
21576 }
21577
21578
21579 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21580 PyObject *resultobj = 0;
21581 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21582 bool result;
21583 void *argp1 = 0 ;
21584 int res1 = 0 ;
21585 PyObject *swig_obj[1] ;
21586
21587 if (!args) SWIG_fail;
21588 swig_obj[0] = args;
21589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21590 if (!SWIG_IsOK(res1)) {
21591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21592 }
21593 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21594 result = (bool) ((arg1)->m_shiftDown);
21595 {
21596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21597 }
21598 return resultobj;
21599 fail:
21600 return NULL;
21601 }
21602
21603
21604 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21605 PyObject *resultobj = 0;
21606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21607 bool arg2 ;
21608 void *argp1 = 0 ;
21609 int res1 = 0 ;
21610 bool val2 ;
21611 int ecode2 = 0 ;
21612 PyObject *swig_obj[2] ;
21613
21614 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21616 if (!SWIG_IsOK(res1)) {
21617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21618 }
21619 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21620 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21621 if (!SWIG_IsOK(ecode2)) {
21622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21623 }
21624 arg2 = static_cast< bool >(val2);
21625 if (arg1) (arg1)->m_altDown = arg2;
21626
21627 resultobj = SWIG_Py_Void();
21628 return resultobj;
21629 fail:
21630 return NULL;
21631 }
21632
21633
21634 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21635 PyObject *resultobj = 0;
21636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21637 bool result;
21638 void *argp1 = 0 ;
21639 int res1 = 0 ;
21640 PyObject *swig_obj[1] ;
21641
21642 if (!args) SWIG_fail;
21643 swig_obj[0] = args;
21644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21645 if (!SWIG_IsOK(res1)) {
21646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21647 }
21648 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21649 result = (bool) ((arg1)->m_altDown);
21650 {
21651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21652 }
21653 return resultobj;
21654 fail:
21655 return NULL;
21656 }
21657
21658
21659 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21660 PyObject *resultobj = 0;
21661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21662 bool arg2 ;
21663 void *argp1 = 0 ;
21664 int res1 = 0 ;
21665 bool val2 ;
21666 int ecode2 = 0 ;
21667 PyObject *swig_obj[2] ;
21668
21669 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21671 if (!SWIG_IsOK(res1)) {
21672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21673 }
21674 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21675 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21676 if (!SWIG_IsOK(ecode2)) {
21677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21678 }
21679 arg2 = static_cast< bool >(val2);
21680 if (arg1) (arg1)->m_metaDown = arg2;
21681
21682 resultobj = SWIG_Py_Void();
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21692 bool result;
21693 void *argp1 = 0 ;
21694 int res1 = 0 ;
21695 PyObject *swig_obj[1] ;
21696
21697 if (!args) SWIG_fail;
21698 swig_obj[0] = args;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21702 }
21703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21704 result = (bool) ((arg1)->m_metaDown);
21705 {
21706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21707 }
21708 return resultobj;
21709 fail:
21710 return NULL;
21711 }
21712
21713
21714 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21715 PyObject *resultobj = 0;
21716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21717 int arg2 ;
21718 void *argp1 = 0 ;
21719 int res1 = 0 ;
21720 int val2 ;
21721 int ecode2 = 0 ;
21722 PyObject *swig_obj[2] ;
21723
21724 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21726 if (!SWIG_IsOK(res1)) {
21727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21728 }
21729 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21730 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21731 if (!SWIG_IsOK(ecode2)) {
21732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21733 }
21734 arg2 = static_cast< int >(val2);
21735 if (arg1) (arg1)->m_wheelRotation = arg2;
21736
21737 resultobj = SWIG_Py_Void();
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21745 PyObject *resultobj = 0;
21746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21747 int result;
21748 void *argp1 = 0 ;
21749 int res1 = 0 ;
21750 PyObject *swig_obj[1] ;
21751
21752 if (!args) SWIG_fail;
21753 swig_obj[0] = args;
21754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21755 if (!SWIG_IsOK(res1)) {
21756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21757 }
21758 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21759 result = (int) ((arg1)->m_wheelRotation);
21760 resultobj = SWIG_From_int(static_cast< int >(result));
21761 return resultobj;
21762 fail:
21763 return NULL;
21764 }
21765
21766
21767 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21768 PyObject *resultobj = 0;
21769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21770 int arg2 ;
21771 void *argp1 = 0 ;
21772 int res1 = 0 ;
21773 int val2 ;
21774 int ecode2 = 0 ;
21775 PyObject *swig_obj[2] ;
21776
21777 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21779 if (!SWIG_IsOK(res1)) {
21780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21781 }
21782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21783 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21784 if (!SWIG_IsOK(ecode2)) {
21785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21786 }
21787 arg2 = static_cast< int >(val2);
21788 if (arg1) (arg1)->m_wheelDelta = arg2;
21789
21790 resultobj = SWIG_Py_Void();
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21798 PyObject *resultobj = 0;
21799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21800 int result;
21801 void *argp1 = 0 ;
21802 int res1 = 0 ;
21803 PyObject *swig_obj[1] ;
21804
21805 if (!args) SWIG_fail;
21806 swig_obj[0] = args;
21807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21808 if (!SWIG_IsOK(res1)) {
21809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21810 }
21811 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21812 result = (int) ((arg1)->m_wheelDelta);
21813 resultobj = SWIG_From_int(static_cast< int >(result));
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21821 PyObject *resultobj = 0;
21822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21823 int arg2 ;
21824 void *argp1 = 0 ;
21825 int res1 = 0 ;
21826 int val2 ;
21827 int ecode2 = 0 ;
21828 PyObject *swig_obj[2] ;
21829
21830 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21832 if (!SWIG_IsOK(res1)) {
21833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21834 }
21835 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21836 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21837 if (!SWIG_IsOK(ecode2)) {
21838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21839 }
21840 arg2 = static_cast< int >(val2);
21841 if (arg1) (arg1)->m_linesPerAction = arg2;
21842
21843 resultobj = SWIG_Py_Void();
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21853 int result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 PyObject *swig_obj[1] ;
21857
21858 if (!args) SWIG_fail;
21859 swig_obj[0] = args;
21860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21863 }
21864 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21865 result = (int) ((arg1)->m_linesPerAction);
21866 resultobj = SWIG_From_int(static_cast< int >(result));
21867 return resultobj;
21868 fail:
21869 return NULL;
21870 }
21871
21872
21873 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21874 PyObject *obj;
21875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21876 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21877 return SWIG_Py_Void();
21878 }
21879
21880 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21881 return SWIG_Python_InitShadowInstance(args);
21882 }
21883
21884 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21885 PyObject *resultobj = 0;
21886 int arg1 = (int) 0 ;
21887 int arg2 = (int) 0 ;
21888 wxSetCursorEvent *result = 0 ;
21889 int val1 ;
21890 int ecode1 = 0 ;
21891 int val2 ;
21892 int ecode2 = 0 ;
21893 PyObject * obj0 = 0 ;
21894 PyObject * obj1 = 0 ;
21895 char * kwnames[] = {
21896 (char *) "x",(char *) "y", NULL
21897 };
21898
21899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21900 if (obj0) {
21901 ecode1 = SWIG_AsVal_int(obj0, &val1);
21902 if (!SWIG_IsOK(ecode1)) {
21903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21904 }
21905 arg1 = static_cast< int >(val1);
21906 }
21907 if (obj1) {
21908 ecode2 = SWIG_AsVal_int(obj1, &val2);
21909 if (!SWIG_IsOK(ecode2)) {
21910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21911 }
21912 arg2 = static_cast< int >(val2);
21913 }
21914 {
21915 PyThreadState* __tstate = wxPyBeginAllowThreads();
21916 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 PyObject *resultobj = 0;
21929 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21930 int result;
21931 void *argp1 = 0 ;
21932 int res1 = 0 ;
21933 PyObject *swig_obj[1] ;
21934
21935 if (!args) SWIG_fail;
21936 swig_obj[0] = args;
21937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21938 if (!SWIG_IsOK(res1)) {
21939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21940 }
21941 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 resultobj = SWIG_From_int(static_cast< int >(result));
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21956 PyObject *resultobj = 0;
21957 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21958 int result;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 PyObject *swig_obj[1] ;
21962
21963 if (!args) SWIG_fail;
21964 swig_obj[0] = args;
21965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21966 if (!SWIG_IsOK(res1)) {
21967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21968 }
21969 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21970 {
21971 PyThreadState* __tstate = wxPyBeginAllowThreads();
21972 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 resultobj = SWIG_From_int(static_cast< int >(result));
21977 return resultobj;
21978 fail:
21979 return NULL;
21980 }
21981
21982
21983 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21984 PyObject *resultobj = 0;
21985 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21986 wxCursor *arg2 = 0 ;
21987 void *argp1 = 0 ;
21988 int res1 = 0 ;
21989 void *argp2 = 0 ;
21990 int res2 = 0 ;
21991 PyObject * obj0 = 0 ;
21992 PyObject * obj1 = 0 ;
21993 char * kwnames[] = {
21994 (char *) "self",(char *) "cursor", NULL
21995 };
21996
21997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21999 if (!SWIG_IsOK(res1)) {
22000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22001 }
22002 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22003 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22004 if (!SWIG_IsOK(res2)) {
22005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22006 }
22007 if (!argp2) {
22008 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22009 }
22010 arg2 = reinterpret_cast< wxCursor * >(argp2);
22011 {
22012 PyThreadState* __tstate = wxPyBeginAllowThreads();
22013 (arg1)->SetCursor((wxCursor const &)*arg2);
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 resultobj = SWIG_Py_Void();
22018 return resultobj;
22019 fail:
22020 return NULL;
22021 }
22022
22023
22024 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22025 PyObject *resultobj = 0;
22026 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22027 wxCursor *result = 0 ;
22028 void *argp1 = 0 ;
22029 int res1 = 0 ;
22030 PyObject *swig_obj[1] ;
22031
22032 if (!args) SWIG_fail;
22033 swig_obj[0] = args;
22034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22035 if (!SWIG_IsOK(res1)) {
22036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22037 }
22038 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 {
22042 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22043 result = (wxCursor *) &_result_ref;
22044 }
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 {
22049 wxCursor* resultptr = new wxCursor(*result);
22050 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22051 }
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059 PyObject *resultobj = 0;
22060 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22061 bool result;
22062 void *argp1 = 0 ;
22063 int res1 = 0 ;
22064 PyObject *swig_obj[1] ;
22065
22066 if (!args) SWIG_fail;
22067 swig_obj[0] = args;
22068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22071 }
22072 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 {
22080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22081 }
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22089 PyObject *obj;
22090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22091 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22092 return SWIG_Py_Void();
22093 }
22094
22095 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096 return SWIG_Python_InitShadowInstance(args);
22097 }
22098
22099 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22100 PyObject *resultobj = 0;
22101 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22102 wxKeyEvent *result = 0 ;
22103 int val1 ;
22104 int ecode1 = 0 ;
22105 PyObject * obj0 = 0 ;
22106 char * kwnames[] = {
22107 (char *) "eventType", NULL
22108 };
22109
22110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22111 if (obj0) {
22112 ecode1 = SWIG_AsVal_int(obj0, &val1);
22113 if (!SWIG_IsOK(ecode1)) {
22114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22115 }
22116 arg1 = static_cast< wxEventType >(val1);
22117 }
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22121 wxPyEndAllowThreads(__tstate);
22122 if (PyErr_Occurred()) SWIG_fail;
22123 }
22124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22132 PyObject *resultobj = 0;
22133 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22134 int result;
22135 void *argp1 = 0 ;
22136 int res1 = 0 ;
22137 PyObject *swig_obj[1] ;
22138
22139 if (!args) SWIG_fail;
22140 swig_obj[0] = args;
22141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22142 if (!SWIG_IsOK(res1)) {
22143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22144 }
22145 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22146 {
22147 PyThreadState* __tstate = wxPyBeginAllowThreads();
22148 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22149 wxPyEndAllowThreads(__tstate);
22150 if (PyErr_Occurred()) SWIG_fail;
22151 }
22152 resultobj = SWIG_From_int(static_cast< int >(result));
22153 return resultobj;
22154 fail:
22155 return NULL;
22156 }
22157
22158
22159 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22160 PyObject *resultobj = 0;
22161 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22162 bool result;
22163 void *argp1 = 0 ;
22164 int res1 = 0 ;
22165 PyObject *swig_obj[1] ;
22166
22167 if (!args) SWIG_fail;
22168 swig_obj[0] = args;
22169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22170 if (!SWIG_IsOK(res1)) {
22171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22172 }
22173 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22174 {
22175 PyThreadState* __tstate = wxPyBeginAllowThreads();
22176 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 {
22181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22182 }
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 PyObject *resultobj = 0;
22191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22192 bool result;
22193 void *argp1 = 0 ;
22194 int res1 = 0 ;
22195 PyObject *swig_obj[1] ;
22196
22197 if (!args) SWIG_fail;
22198 swig_obj[0] = args;
22199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22200 if (!SWIG_IsOK(res1)) {
22201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22202 }
22203 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 {
22211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22212 }
22213 return resultobj;
22214 fail:
22215 return NULL;
22216 }
22217
22218
22219 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22220 PyObject *resultobj = 0;
22221 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22222 bool result;
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_wxKeyEvent, 0 | 0 );
22230 if (!SWIG_IsOK(res1)) {
22231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22232 }
22233 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 {
22241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22242 }
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 PyObject *resultobj = 0;
22251 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22252 bool result;
22253 void *argp1 = 0 ;
22254 int res1 = 0 ;
22255 PyObject *swig_obj[1] ;
22256
22257 if (!args) SWIG_fail;
22258 swig_obj[0] = args;
22259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22260 if (!SWIG_IsOK(res1)) {
22261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22262 }
22263 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22264 {
22265 PyThreadState* __tstate = wxPyBeginAllowThreads();
22266 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 {
22271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22272 }
22273 return resultobj;
22274 fail:
22275 return NULL;
22276 }
22277
22278
22279 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22280 PyObject *resultobj = 0;
22281 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22282 bool result;
22283 void *argp1 = 0 ;
22284 int res1 = 0 ;
22285 PyObject *swig_obj[1] ;
22286
22287 if (!args) SWIG_fail;
22288 swig_obj[0] = args;
22289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22290 if (!SWIG_IsOK(res1)) {
22291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22292 }
22293 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 {
22301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22302 }
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22310 PyObject *resultobj = 0;
22311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22312 bool result;
22313 void *argp1 = 0 ;
22314 int res1 = 0 ;
22315 PyObject *swig_obj[1] ;
22316
22317 if (!args) SWIG_fail;
22318 swig_obj[0] = args;
22319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22320 if (!SWIG_IsOK(res1)) {
22321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22322 }
22323 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 {
22331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22332 }
22333 return resultobj;
22334 fail:
22335 return NULL;
22336 }
22337
22338
22339 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22340 PyObject *resultobj = 0;
22341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22342 int result;
22343 void *argp1 = 0 ;
22344 int res1 = 0 ;
22345 PyObject *swig_obj[1] ;
22346
22347 if (!args) SWIG_fail;
22348 swig_obj[0] = args;
22349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22350 if (!SWIG_IsOK(res1)) {
22351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22352 }
22353 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22354 {
22355 PyThreadState* __tstate = wxPyBeginAllowThreads();
22356 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22357 wxPyEndAllowThreads(__tstate);
22358 if (PyErr_Occurred()) SWIG_fail;
22359 }
22360 resultobj = SWIG_From_int(static_cast< int >(result));
22361 return resultobj;
22362 fail:
22363 return NULL;
22364 }
22365
22366
22367 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22368 PyObject *resultobj = 0;
22369 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22370 int result;
22371 void *argp1 = 0 ;
22372 int res1 = 0 ;
22373 PyObject *swig_obj[1] ;
22374
22375 if (!args) SWIG_fail;
22376 swig_obj[0] = args;
22377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22378 if (!SWIG_IsOK(res1)) {
22379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22380 }
22381 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22385 wxPyEndAllowThreads(__tstate);
22386 if (PyErr_Occurred()) SWIG_fail;
22387 }
22388 resultobj = SWIG_From_int(static_cast< int >(result));
22389 return resultobj;
22390 fail:
22391 return NULL;
22392 }
22393
22394
22395 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22396 PyObject *resultobj = 0;
22397 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22398 int arg2 ;
22399 void *argp1 = 0 ;
22400 int res1 = 0 ;
22401 int val2 ;
22402 int ecode2 = 0 ;
22403 PyObject * obj0 = 0 ;
22404 PyObject * obj1 = 0 ;
22405 char * kwnames[] = {
22406 (char *) "self",(char *) "uniChar", NULL
22407 };
22408
22409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22411 if (!SWIG_IsOK(res1)) {
22412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22413 }
22414 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22415 ecode2 = SWIG_AsVal_int(obj1, &val2);
22416 if (!SWIG_IsOK(ecode2)) {
22417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22418 }
22419 arg2 = static_cast< int >(val2);
22420 {
22421 PyThreadState* __tstate = wxPyBeginAllowThreads();
22422 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 resultobj = SWIG_Py_Void();
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22436 unsigned int result;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 PyObject *swig_obj[1] ;
22440
22441 if (!args) SWIG_fail;
22442 swig_obj[0] = args;
22443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22444 if (!SWIG_IsOK(res1)) {
22445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22446 }
22447 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22462 PyObject *resultobj = 0;
22463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22464 unsigned int result;
22465 void *argp1 = 0 ;
22466 int res1 = 0 ;
22467 PyObject *swig_obj[1] ;
22468
22469 if (!args) SWIG_fail;
22470 swig_obj[0] = args;
22471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22472 if (!SWIG_IsOK(res1)) {
22473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22474 }
22475 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22490 PyObject *resultobj = 0;
22491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22492 wxPoint result;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 PyObject *swig_obj[1] ;
22496
22497 if (!args) SWIG_fail;
22498 swig_obj[0] = args;
22499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22500 if (!SWIG_IsOK(res1)) {
22501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22502 }
22503 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 result = (arg1)->GetPosition();
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22518 PyObject *resultobj = 0;
22519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22520 long *arg2 = (long *) 0 ;
22521 long *arg3 = (long *) 0 ;
22522 void *argp1 = 0 ;
22523 int res1 = 0 ;
22524 long temp2 ;
22525 int res2 = SWIG_TMPOBJ ;
22526 long temp3 ;
22527 int res3 = SWIG_TMPOBJ ;
22528 PyObject *swig_obj[1] ;
22529
22530 arg2 = &temp2;
22531 arg3 = &temp3;
22532 if (!args) SWIG_fail;
22533 swig_obj[0] = args;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22537 }
22538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 (arg1)->GetPosition(arg2,arg3);
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 resultobj = SWIG_Py_Void();
22546 if (SWIG_IsTmpObj(res2)) {
22547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22548 } else {
22549 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22551 }
22552 if (SWIG_IsTmpObj(res3)) {
22553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22554 } else {
22555 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22557 }
22558 return resultobj;
22559 fail:
22560 return NULL;
22561 }
22562
22563
22564 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22565 PyObject *resultobj = 0;
22566 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22567 int result;
22568 void *argp1 = 0 ;
22569 int res1 = 0 ;
22570 PyObject *swig_obj[1] ;
22571
22572 if (!args) SWIG_fail;
22573 swig_obj[0] = args;
22574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22575 if (!SWIG_IsOK(res1)) {
22576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22577 }
22578 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22579 {
22580 PyThreadState* __tstate = wxPyBeginAllowThreads();
22581 result = (int)((wxKeyEvent const *)arg1)->GetX();
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 resultobj = SWIG_From_int(static_cast< int >(result));
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22593 PyObject *resultobj = 0;
22594 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22595 int result;
22596 void *argp1 = 0 ;
22597 int res1 = 0 ;
22598 PyObject *swig_obj[1] ;
22599
22600 if (!args) SWIG_fail;
22601 swig_obj[0] = args;
22602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22603 if (!SWIG_IsOK(res1)) {
22604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22605 }
22606 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 result = (int)((wxKeyEvent const *)arg1)->GetY();
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 resultobj = SWIG_From_int(static_cast< int >(result));
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22621 PyObject *resultobj = 0;
22622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22623 int arg2 ;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 int val2 ;
22627 int ecode2 = 0 ;
22628 PyObject *swig_obj[2] ;
22629
22630 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22632 if (!SWIG_IsOK(res1)) {
22633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22634 }
22635 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22636 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22637 if (!SWIG_IsOK(ecode2)) {
22638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22639 }
22640 arg2 = static_cast< int >(val2);
22641 if (arg1) (arg1)->m_x = arg2;
22642
22643 resultobj = SWIG_Py_Void();
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22651 PyObject *resultobj = 0;
22652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22653 int result;
22654 void *argp1 = 0 ;
22655 int res1 = 0 ;
22656 PyObject *swig_obj[1] ;
22657
22658 if (!args) SWIG_fail;
22659 swig_obj[0] = args;
22660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22661 if (!SWIG_IsOK(res1)) {
22662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22663 }
22664 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22665 result = (int) ((arg1)->m_x);
22666 resultobj = SWIG_From_int(static_cast< int >(result));
22667 return resultobj;
22668 fail:
22669 return NULL;
22670 }
22671
22672
22673 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22674 PyObject *resultobj = 0;
22675 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22676 int arg2 ;
22677 void *argp1 = 0 ;
22678 int res1 = 0 ;
22679 int val2 ;
22680 int ecode2 = 0 ;
22681 PyObject *swig_obj[2] ;
22682
22683 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22685 if (!SWIG_IsOK(res1)) {
22686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22687 }
22688 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22689 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22690 if (!SWIG_IsOK(ecode2)) {
22691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22692 }
22693 arg2 = static_cast< int >(val2);
22694 if (arg1) (arg1)->m_y = arg2;
22695
22696 resultobj = SWIG_Py_Void();
22697 return resultobj;
22698 fail:
22699 return NULL;
22700 }
22701
22702
22703 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22704 PyObject *resultobj = 0;
22705 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22706 int result;
22707 void *argp1 = 0 ;
22708 int res1 = 0 ;
22709 PyObject *swig_obj[1] ;
22710
22711 if (!args) SWIG_fail;
22712 swig_obj[0] = args;
22713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22716 }
22717 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22718 result = (int) ((arg1)->m_y);
22719 resultobj = SWIG_From_int(static_cast< int >(result));
22720 return resultobj;
22721 fail:
22722 return NULL;
22723 }
22724
22725
22726 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22727 PyObject *resultobj = 0;
22728 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22729 long arg2 ;
22730 void *argp1 = 0 ;
22731 int res1 = 0 ;
22732 long val2 ;
22733 int ecode2 = 0 ;
22734 PyObject *swig_obj[2] ;
22735
22736 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22738 if (!SWIG_IsOK(res1)) {
22739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22740 }
22741 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22742 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22743 if (!SWIG_IsOK(ecode2)) {
22744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22745 }
22746 arg2 = static_cast< long >(val2);
22747 if (arg1) (arg1)->m_keyCode = arg2;
22748
22749 resultobj = SWIG_Py_Void();
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22757 PyObject *resultobj = 0;
22758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22759 long result;
22760 void *argp1 = 0 ;
22761 int res1 = 0 ;
22762 PyObject *swig_obj[1] ;
22763
22764 if (!args) SWIG_fail;
22765 swig_obj[0] = args;
22766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22767 if (!SWIG_IsOK(res1)) {
22768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22769 }
22770 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22771 result = (long) ((arg1)->m_keyCode);
22772 resultobj = SWIG_From_long(static_cast< long >(result));
22773 return resultobj;
22774 fail:
22775 return NULL;
22776 }
22777
22778
22779 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22780 PyObject *resultobj = 0;
22781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22782 bool arg2 ;
22783 void *argp1 = 0 ;
22784 int res1 = 0 ;
22785 bool val2 ;
22786 int ecode2 = 0 ;
22787 PyObject *swig_obj[2] ;
22788
22789 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22791 if (!SWIG_IsOK(res1)) {
22792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22793 }
22794 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22795 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22796 if (!SWIG_IsOK(ecode2)) {
22797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22798 }
22799 arg2 = static_cast< bool >(val2);
22800 if (arg1) (arg1)->m_controlDown = arg2;
22801
22802 resultobj = SWIG_Py_Void();
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22810 PyObject *resultobj = 0;
22811 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22812 bool result;
22813 void *argp1 = 0 ;
22814 int res1 = 0 ;
22815 PyObject *swig_obj[1] ;
22816
22817 if (!args) SWIG_fail;
22818 swig_obj[0] = args;
22819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22820 if (!SWIG_IsOK(res1)) {
22821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22822 }
22823 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22824 result = (bool) ((arg1)->m_controlDown);
22825 {
22826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22827 }
22828 return resultobj;
22829 fail:
22830 return NULL;
22831 }
22832
22833
22834 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22835 PyObject *resultobj = 0;
22836 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22837 bool arg2 ;
22838 void *argp1 = 0 ;
22839 int res1 = 0 ;
22840 bool val2 ;
22841 int ecode2 = 0 ;
22842 PyObject *swig_obj[2] ;
22843
22844 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22846 if (!SWIG_IsOK(res1)) {
22847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22848 }
22849 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22850 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22851 if (!SWIG_IsOK(ecode2)) {
22852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22853 }
22854 arg2 = static_cast< bool >(val2);
22855 if (arg1) (arg1)->m_shiftDown = arg2;
22856
22857 resultobj = SWIG_Py_Void();
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22865 PyObject *resultobj = 0;
22866 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22867 bool result;
22868 void *argp1 = 0 ;
22869 int res1 = 0 ;
22870 PyObject *swig_obj[1] ;
22871
22872 if (!args) SWIG_fail;
22873 swig_obj[0] = args;
22874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22875 if (!SWIG_IsOK(res1)) {
22876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22877 }
22878 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22879 result = (bool) ((arg1)->m_shiftDown);
22880 {
22881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22882 }
22883 return resultobj;
22884 fail:
22885 return NULL;
22886 }
22887
22888
22889 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22890 PyObject *resultobj = 0;
22891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22892 bool arg2 ;
22893 void *argp1 = 0 ;
22894 int res1 = 0 ;
22895 bool val2 ;
22896 int ecode2 = 0 ;
22897 PyObject *swig_obj[2] ;
22898
22899 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22901 if (!SWIG_IsOK(res1)) {
22902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22903 }
22904 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22905 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22906 if (!SWIG_IsOK(ecode2)) {
22907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22908 }
22909 arg2 = static_cast< bool >(val2);
22910 if (arg1) (arg1)->m_altDown = arg2;
22911
22912 resultobj = SWIG_Py_Void();
22913 return resultobj;
22914 fail:
22915 return NULL;
22916 }
22917
22918
22919 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22920 PyObject *resultobj = 0;
22921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22922 bool result;
22923 void *argp1 = 0 ;
22924 int res1 = 0 ;
22925 PyObject *swig_obj[1] ;
22926
22927 if (!args) SWIG_fail;
22928 swig_obj[0] = args;
22929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22930 if (!SWIG_IsOK(res1)) {
22931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22932 }
22933 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22934 result = (bool) ((arg1)->m_altDown);
22935 {
22936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22937 }
22938 return resultobj;
22939 fail:
22940 return NULL;
22941 }
22942
22943
22944 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22945 PyObject *resultobj = 0;
22946 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22947 bool arg2 ;
22948 void *argp1 = 0 ;
22949 int res1 = 0 ;
22950 bool val2 ;
22951 int ecode2 = 0 ;
22952 PyObject *swig_obj[2] ;
22953
22954 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22956 if (!SWIG_IsOK(res1)) {
22957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22958 }
22959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22960 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22961 if (!SWIG_IsOK(ecode2)) {
22962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22963 }
22964 arg2 = static_cast< bool >(val2);
22965 if (arg1) (arg1)->m_metaDown = arg2;
22966
22967 resultobj = SWIG_Py_Void();
22968 return resultobj;
22969 fail:
22970 return NULL;
22971 }
22972
22973
22974 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22975 PyObject *resultobj = 0;
22976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22977 bool result;
22978 void *argp1 = 0 ;
22979 int res1 = 0 ;
22980 PyObject *swig_obj[1] ;
22981
22982 if (!args) SWIG_fail;
22983 swig_obj[0] = args;
22984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22987 }
22988 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22989 result = (bool) ((arg1)->m_metaDown);
22990 {
22991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22992 }
22993 return resultobj;
22994 fail:
22995 return NULL;
22996 }
22997
22998
22999 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23000 PyObject *resultobj = 0;
23001 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23002 bool arg2 ;
23003 void *argp1 = 0 ;
23004 int res1 = 0 ;
23005 bool val2 ;
23006 int ecode2 = 0 ;
23007 PyObject *swig_obj[2] ;
23008
23009 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23011 if (!SWIG_IsOK(res1)) {
23012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23013 }
23014 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23015 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23016 if (!SWIG_IsOK(ecode2)) {
23017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23018 }
23019 arg2 = static_cast< bool >(val2);
23020 if (arg1) (arg1)->m_scanCode = arg2;
23021
23022 resultobj = SWIG_Py_Void();
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23030 PyObject *resultobj = 0;
23031 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23032 bool result;
23033 void *argp1 = 0 ;
23034 int res1 = 0 ;
23035 PyObject *swig_obj[1] ;
23036
23037 if (!args) SWIG_fail;
23038 swig_obj[0] = args;
23039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23040 if (!SWIG_IsOK(res1)) {
23041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23042 }
23043 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23044 result = (bool) ((arg1)->m_scanCode);
23045 {
23046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23047 }
23048 return resultobj;
23049 fail:
23050 return NULL;
23051 }
23052
23053
23054 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23055 PyObject *resultobj = 0;
23056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23057 unsigned int arg2 ;
23058 void *argp1 = 0 ;
23059 int res1 = 0 ;
23060 unsigned int val2 ;
23061 int ecode2 = 0 ;
23062 PyObject *swig_obj[2] ;
23063
23064 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23066 if (!SWIG_IsOK(res1)) {
23067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23068 }
23069 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23070 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23071 if (!SWIG_IsOK(ecode2)) {
23072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23073 }
23074 arg2 = static_cast< unsigned int >(val2);
23075 if (arg1) (arg1)->m_rawCode = arg2;
23076
23077 resultobj = SWIG_Py_Void();
23078 return resultobj;
23079 fail:
23080 return NULL;
23081 }
23082
23083
23084 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23085 PyObject *resultobj = 0;
23086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23087 unsigned int result;
23088 void *argp1 = 0 ;
23089 int res1 = 0 ;
23090 PyObject *swig_obj[1] ;
23091
23092 if (!args) SWIG_fail;
23093 swig_obj[0] = args;
23094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23095 if (!SWIG_IsOK(res1)) {
23096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23097 }
23098 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23099 result = (unsigned int) ((arg1)->m_rawCode);
23100 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23101 return resultobj;
23102 fail:
23103 return NULL;
23104 }
23105
23106
23107 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23108 PyObject *resultobj = 0;
23109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23110 unsigned int arg2 ;
23111 void *argp1 = 0 ;
23112 int res1 = 0 ;
23113 unsigned int val2 ;
23114 int ecode2 = 0 ;
23115 PyObject *swig_obj[2] ;
23116
23117 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23121 }
23122 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23123 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23124 if (!SWIG_IsOK(ecode2)) {
23125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23126 }
23127 arg2 = static_cast< unsigned int >(val2);
23128 if (arg1) (arg1)->m_rawFlags = arg2;
23129
23130 resultobj = SWIG_Py_Void();
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23138 PyObject *resultobj = 0;
23139 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23140 unsigned int result;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 PyObject *swig_obj[1] ;
23144
23145 if (!args) SWIG_fail;
23146 swig_obj[0] = args;
23147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23150 }
23151 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23152 result = (unsigned int) ((arg1)->m_rawFlags);
23153 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23161 PyObject *obj;
23162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23163 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23164 return SWIG_Py_Void();
23165 }
23166
23167 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 return SWIG_Python_InitShadowInstance(args);
23169 }
23170
23171 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23172 PyObject *resultobj = 0;
23173 wxSize const &arg1_defvalue = wxDefaultSize ;
23174 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23175 int arg2 = (int) 0 ;
23176 wxSizeEvent *result = 0 ;
23177 wxSize temp1 ;
23178 int val2 ;
23179 int ecode2 = 0 ;
23180 PyObject * obj0 = 0 ;
23181 PyObject * obj1 = 0 ;
23182 char * kwnames[] = {
23183 (char *) "sz",(char *) "winid", NULL
23184 };
23185
23186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23187 if (obj0) {
23188 {
23189 arg1 = &temp1;
23190 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23191 }
23192 }
23193 if (obj1) {
23194 ecode2 = SWIG_AsVal_int(obj1, &val2);
23195 if (!SWIG_IsOK(ecode2)) {
23196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23197 }
23198 arg2 = static_cast< int >(val2);
23199 }
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214 PyObject *resultobj = 0;
23215 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23216 wxSize result;
23217 void *argp1 = 0 ;
23218 int res1 = 0 ;
23219 PyObject *swig_obj[1] ;
23220
23221 if (!args) SWIG_fail;
23222 swig_obj[0] = args;
23223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23224 if (!SWIG_IsOK(res1)) {
23225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23226 }
23227 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 result = ((wxSizeEvent const *)arg1)->GetSize();
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23242 PyObject *resultobj = 0;
23243 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23244 wxRect result;
23245 void *argp1 = 0 ;
23246 int res1 = 0 ;
23247 PyObject *swig_obj[1] ;
23248
23249 if (!args) SWIG_fail;
23250 swig_obj[0] = args;
23251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23252 if (!SWIG_IsOK(res1)) {
23253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23254 }
23255 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23256 {
23257 PyThreadState* __tstate = wxPyBeginAllowThreads();
23258 result = ((wxSizeEvent const *)arg1)->GetRect();
23259 wxPyEndAllowThreads(__tstate);
23260 if (PyErr_Occurred()) SWIG_fail;
23261 }
23262 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23263 return resultobj;
23264 fail:
23265 return NULL;
23266 }
23267
23268
23269 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23270 PyObject *resultobj = 0;
23271 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23272 wxRect arg2 ;
23273 void *argp1 = 0 ;
23274 int res1 = 0 ;
23275 void *argp2 ;
23276 int res2 = 0 ;
23277 PyObject * obj0 = 0 ;
23278 PyObject * obj1 = 0 ;
23279 char * kwnames[] = {
23280 (char *) "self",(char *) "rect", NULL
23281 };
23282
23283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23285 if (!SWIG_IsOK(res1)) {
23286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23287 }
23288 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23289 {
23290 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23291 if (!SWIG_IsOK(res2)) {
23292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23293 }
23294 if (!argp2) {
23295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23296 } else {
23297 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23298 arg2 = *temp;
23299 if (SWIG_IsNewObj(res2)) delete temp;
23300 }
23301 }
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 (arg1)->SetRect(arg2);
23305 wxPyEndAllowThreads(__tstate);
23306 if (PyErr_Occurred()) SWIG_fail;
23307 }
23308 resultobj = SWIG_Py_Void();
23309 return resultobj;
23310 fail:
23311 return NULL;
23312 }
23313
23314
23315 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23316 PyObject *resultobj = 0;
23317 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23318 wxSize arg2 ;
23319 void *argp1 = 0 ;
23320 int res1 = 0 ;
23321 void *argp2 ;
23322 int res2 = 0 ;
23323 PyObject * obj0 = 0 ;
23324 PyObject * obj1 = 0 ;
23325 char * kwnames[] = {
23326 (char *) "self",(char *) "size", NULL
23327 };
23328
23329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23331 if (!SWIG_IsOK(res1)) {
23332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23333 }
23334 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23335 {
23336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23337 if (!SWIG_IsOK(res2)) {
23338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23339 }
23340 if (!argp2) {
23341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23342 } else {
23343 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23344 arg2 = *temp;
23345 if (SWIG_IsNewObj(res2)) delete temp;
23346 }
23347 }
23348 {
23349 PyThreadState* __tstate = wxPyBeginAllowThreads();
23350 wxSizeEvent_SetSize(arg1,arg2);
23351 wxPyEndAllowThreads(__tstate);
23352 if (PyErr_Occurred()) SWIG_fail;
23353 }
23354 resultobj = SWIG_Py_Void();
23355 return resultobj;
23356 fail:
23357 return NULL;
23358 }
23359
23360
23361 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23362 PyObject *resultobj = 0;
23363 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23364 wxSize *arg2 = (wxSize *) 0 ;
23365 void *argp1 = 0 ;
23366 int res1 = 0 ;
23367 void *argp2 = 0 ;
23368 int res2 = 0 ;
23369 PyObject *swig_obj[2] ;
23370
23371 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23373 if (!SWIG_IsOK(res1)) {
23374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23375 }
23376 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23377 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23378 if (!SWIG_IsOK(res2)) {
23379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23380 }
23381 arg2 = reinterpret_cast< wxSize * >(argp2);
23382 if (arg1) (arg1)->m_size = *arg2;
23383
23384 resultobj = SWIG_Py_Void();
23385 return resultobj;
23386 fail:
23387 return NULL;
23388 }
23389
23390
23391 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23392 PyObject *resultobj = 0;
23393 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23394 wxSize *result = 0 ;
23395 void *argp1 = 0 ;
23396 int res1 = 0 ;
23397 PyObject *swig_obj[1] ;
23398
23399 if (!args) SWIG_fail;
23400 swig_obj[0] = args;
23401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23402 if (!SWIG_IsOK(res1)) {
23403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23404 }
23405 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23406 result = (wxSize *)& ((arg1)->m_size);
23407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23408 return resultobj;
23409 fail:
23410 return NULL;
23411 }
23412
23413
23414 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23415 PyObject *resultobj = 0;
23416 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23417 wxRect *arg2 = (wxRect *) 0 ;
23418 void *argp1 = 0 ;
23419 int res1 = 0 ;
23420 void *argp2 = 0 ;
23421 int res2 = 0 ;
23422 PyObject *swig_obj[2] ;
23423
23424 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23426 if (!SWIG_IsOK(res1)) {
23427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23428 }
23429 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23430 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23431 if (!SWIG_IsOK(res2)) {
23432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23433 }
23434 arg2 = reinterpret_cast< wxRect * >(argp2);
23435 if (arg1) (arg1)->m_rect = *arg2;
23436
23437 resultobj = SWIG_Py_Void();
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23445 PyObject *resultobj = 0;
23446 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23447 wxRect *result = 0 ;
23448 void *argp1 = 0 ;
23449 int res1 = 0 ;
23450 PyObject *swig_obj[1] ;
23451
23452 if (!args) SWIG_fail;
23453 swig_obj[0] = args;
23454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23455 if (!SWIG_IsOK(res1)) {
23456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23457 }
23458 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23459 result = (wxRect *)& ((arg1)->m_rect);
23460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23461 return resultobj;
23462 fail:
23463 return NULL;
23464 }
23465
23466
23467 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23468 PyObject *obj;
23469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23470 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23471 return SWIG_Py_Void();
23472 }
23473
23474 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23475 return SWIG_Python_InitShadowInstance(args);
23476 }
23477
23478 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23479 PyObject *resultobj = 0;
23480 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23481 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23482 int arg2 = (int) 0 ;
23483 wxMoveEvent *result = 0 ;
23484 wxPoint temp1 ;
23485 int val2 ;
23486 int ecode2 = 0 ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 char * kwnames[] = {
23490 (char *) "pos",(char *) "winid", NULL
23491 };
23492
23493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23494 if (obj0) {
23495 {
23496 arg1 = &temp1;
23497 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23498 }
23499 }
23500 if (obj1) {
23501 ecode2 = SWIG_AsVal_int(obj1, &val2);
23502 if (!SWIG_IsOK(ecode2)) {
23503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23504 }
23505 arg2 = static_cast< int >(val2);
23506 }
23507 {
23508 PyThreadState* __tstate = wxPyBeginAllowThreads();
23509 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23521 PyObject *resultobj = 0;
23522 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23523 wxPoint result;
23524 void *argp1 = 0 ;
23525 int res1 = 0 ;
23526 PyObject *swig_obj[1] ;
23527
23528 if (!args) SWIG_fail;
23529 swig_obj[0] = args;
23530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23531 if (!SWIG_IsOK(res1)) {
23532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23533 }
23534 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23535 {
23536 PyThreadState* __tstate = wxPyBeginAllowThreads();
23537 result = ((wxMoveEvent const *)arg1)->GetPosition();
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23549 PyObject *resultobj = 0;
23550 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23551 wxRect result;
23552 void *argp1 = 0 ;
23553 int res1 = 0 ;
23554 PyObject *swig_obj[1] ;
23555
23556 if (!args) SWIG_fail;
23557 swig_obj[0] = args;
23558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23559 if (!SWIG_IsOK(res1)) {
23560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23561 }
23562 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23563 {
23564 PyThreadState* __tstate = wxPyBeginAllowThreads();
23565 result = ((wxMoveEvent const *)arg1)->GetRect();
23566 wxPyEndAllowThreads(__tstate);
23567 if (PyErr_Occurred()) SWIG_fail;
23568 }
23569 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23579 wxRect *arg2 = 0 ;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 wxRect temp2 ;
23583 PyObject * obj0 = 0 ;
23584 PyObject * obj1 = 0 ;
23585 char * kwnames[] = {
23586 (char *) "self",(char *) "rect", NULL
23587 };
23588
23589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23591 if (!SWIG_IsOK(res1)) {
23592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23593 }
23594 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23595 {
23596 arg2 = &temp2;
23597 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23598 }
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 (arg1)->SetRect((wxRect const &)*arg2);
23602 wxPyEndAllowThreads(__tstate);
23603 if (PyErr_Occurred()) SWIG_fail;
23604 }
23605 resultobj = SWIG_Py_Void();
23606 return resultobj;
23607 fail:
23608 return NULL;
23609 }
23610
23611
23612 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23613 PyObject *resultobj = 0;
23614 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23615 wxPoint *arg2 = 0 ;
23616 void *argp1 = 0 ;
23617 int res1 = 0 ;
23618 wxPoint temp2 ;
23619 PyObject * obj0 = 0 ;
23620 PyObject * obj1 = 0 ;
23621 char * kwnames[] = {
23622 (char *) "self",(char *) "pos", NULL
23623 };
23624
23625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23627 if (!SWIG_IsOK(res1)) {
23628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23629 }
23630 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23631 {
23632 arg2 = &temp2;
23633 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23634 }
23635 {
23636 PyThreadState* __tstate = wxPyBeginAllowThreads();
23637 (arg1)->SetPosition((wxPoint const &)*arg2);
23638 wxPyEndAllowThreads(__tstate);
23639 if (PyErr_Occurred()) SWIG_fail;
23640 }
23641 resultobj = SWIG_Py_Void();
23642 return resultobj;
23643 fail:
23644 return NULL;
23645 }
23646
23647
23648 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23649 PyObject *obj;
23650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23651 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23652 return SWIG_Py_Void();
23653 }
23654
23655 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23656 return SWIG_Python_InitShadowInstance(args);
23657 }
23658
23659 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj = 0;
23661 int arg1 = (int) 0 ;
23662 wxPaintEvent *result = 0 ;
23663 int val1 ;
23664 int ecode1 = 0 ;
23665 PyObject * obj0 = 0 ;
23666 char * kwnames[] = {
23667 (char *) "Id", NULL
23668 };
23669
23670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23671 if (obj0) {
23672 ecode1 = SWIG_AsVal_int(obj0, &val1);
23673 if (!SWIG_IsOK(ecode1)) {
23674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23675 }
23676 arg1 = static_cast< int >(val1);
23677 }
23678 {
23679 PyThreadState* __tstate = wxPyBeginAllowThreads();
23680 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23681 wxPyEndAllowThreads(__tstate);
23682 if (PyErr_Occurred()) SWIG_fail;
23683 }
23684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23685 return resultobj;
23686 fail:
23687 return NULL;
23688 }
23689
23690
23691 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23692 PyObject *obj;
23693 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23694 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23695 return SWIG_Py_Void();
23696 }
23697
23698 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23699 return SWIG_Python_InitShadowInstance(args);
23700 }
23701
23702 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23703 PyObject *resultobj = 0;
23704 int arg1 = (int) 0 ;
23705 wxNcPaintEvent *result = 0 ;
23706 int val1 ;
23707 int ecode1 = 0 ;
23708 PyObject * obj0 = 0 ;
23709 char * kwnames[] = {
23710 (char *) "winid", NULL
23711 };
23712
23713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23714 if (obj0) {
23715 ecode1 = SWIG_AsVal_int(obj0, &val1);
23716 if (!SWIG_IsOK(ecode1)) {
23717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23718 }
23719 arg1 = static_cast< int >(val1);
23720 }
23721 {
23722 PyThreadState* __tstate = wxPyBeginAllowThreads();
23723 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23724 wxPyEndAllowThreads(__tstate);
23725 if (PyErr_Occurred()) SWIG_fail;
23726 }
23727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23728 return resultobj;
23729 fail:
23730 return NULL;
23731 }
23732
23733
23734 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23735 PyObject *obj;
23736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23737 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23738 return SWIG_Py_Void();
23739 }
23740
23741 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 return SWIG_Python_InitShadowInstance(args);
23743 }
23744
23745 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23746 PyObject *resultobj = 0;
23747 int arg1 = (int) 0 ;
23748 wxDC *arg2 = (wxDC *) NULL ;
23749 wxEraseEvent *result = 0 ;
23750 int val1 ;
23751 int ecode1 = 0 ;
23752 void *argp2 = 0 ;
23753 int res2 = 0 ;
23754 PyObject * obj0 = 0 ;
23755 PyObject * obj1 = 0 ;
23756 char * kwnames[] = {
23757 (char *) "Id",(char *) "dc", NULL
23758 };
23759
23760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23761 if (obj0) {
23762 ecode1 = SWIG_AsVal_int(obj0, &val1);
23763 if (!SWIG_IsOK(ecode1)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23765 }
23766 arg1 = static_cast< int >(val1);
23767 }
23768 if (obj1) {
23769 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23770 if (!SWIG_IsOK(res2)) {
23771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23772 }
23773 arg2 = reinterpret_cast< wxDC * >(argp2);
23774 }
23775 {
23776 PyThreadState* __tstate = wxPyBeginAllowThreads();
23777 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23789 PyObject *resultobj = 0;
23790 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23791 wxDC *result = 0 ;
23792 void *argp1 = 0 ;
23793 int res1 = 0 ;
23794 PyObject *swig_obj[1] ;
23795
23796 if (!args) SWIG_fail;
23797 swig_obj[0] = args;
23798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23799 if (!SWIG_IsOK(res1)) {
23800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23801 }
23802 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 resultobj = wxPyMake_wxObject(result, (bool)0);
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23819 PyObject *obj;
23820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23821 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23822 return SWIG_Py_Void();
23823 }
23824
23825 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 return SWIG_Python_InitShadowInstance(args);
23827 }
23828
23829 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj = 0;
23831 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23832 int arg2 = (int) 0 ;
23833 wxFocusEvent *result = 0 ;
23834 int val1 ;
23835 int ecode1 = 0 ;
23836 int val2 ;
23837 int ecode2 = 0 ;
23838 PyObject * obj0 = 0 ;
23839 PyObject * obj1 = 0 ;
23840 char * kwnames[] = {
23841 (char *) "type",(char *) "winid", NULL
23842 };
23843
23844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23845 if (obj0) {
23846 ecode1 = SWIG_AsVal_int(obj0, &val1);
23847 if (!SWIG_IsOK(ecode1)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23849 }
23850 arg1 = static_cast< wxEventType >(val1);
23851 }
23852 if (obj1) {
23853 ecode2 = SWIG_AsVal_int(obj1, &val2);
23854 if (!SWIG_IsOK(ecode2)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23856 }
23857 arg2 = static_cast< int >(val2);
23858 }
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23862 wxPyEndAllowThreads(__tstate);
23863 if (PyErr_Occurred()) SWIG_fail;
23864 }
23865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23866 return resultobj;
23867 fail:
23868 return NULL;
23869 }
23870
23871
23872 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23873 PyObject *resultobj = 0;
23874 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23875 wxWindow *result = 0 ;
23876 void *argp1 = 0 ;
23877 int res1 = 0 ;
23878 PyObject *swig_obj[1] ;
23879
23880 if (!args) SWIG_fail;
23881 swig_obj[0] = args;
23882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23883 if (!SWIG_IsOK(res1)) {
23884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23885 }
23886 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23890 wxPyEndAllowThreads(__tstate);
23891 if (PyErr_Occurred()) SWIG_fail;
23892 }
23893 {
23894 resultobj = wxPyMake_wxObject(result, (bool)0);
23895 }
23896 return resultobj;
23897 fail:
23898 return NULL;
23899 }
23900
23901
23902 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23903 PyObject *resultobj = 0;
23904 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23905 wxWindow *arg2 = (wxWindow *) 0 ;
23906 void *argp1 = 0 ;
23907 int res1 = 0 ;
23908 void *argp2 = 0 ;
23909 int res2 = 0 ;
23910 PyObject * obj0 = 0 ;
23911 PyObject * obj1 = 0 ;
23912 char * kwnames[] = {
23913 (char *) "self",(char *) "win", NULL
23914 };
23915
23916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23918 if (!SWIG_IsOK(res1)) {
23919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23920 }
23921 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23922 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23923 if (!SWIG_IsOK(res2)) {
23924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23925 }
23926 arg2 = reinterpret_cast< wxWindow * >(argp2);
23927 {
23928 PyThreadState* __tstate = wxPyBeginAllowThreads();
23929 (arg1)->SetWindow(arg2);
23930 wxPyEndAllowThreads(__tstate);
23931 if (PyErr_Occurred()) SWIG_fail;
23932 }
23933 resultobj = SWIG_Py_Void();
23934 return resultobj;
23935 fail:
23936 return NULL;
23937 }
23938
23939
23940 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23941 PyObject *obj;
23942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23943 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23944 return SWIG_Py_Void();
23945 }
23946
23947 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 return SWIG_Python_InitShadowInstance(args);
23949 }
23950
23951 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj = 0;
23953 wxWindow *arg1 = (wxWindow *) NULL ;
23954 wxChildFocusEvent *result = 0 ;
23955 void *argp1 = 0 ;
23956 int res1 = 0 ;
23957 PyObject * obj0 = 0 ;
23958 char * kwnames[] = {
23959 (char *) "win", NULL
23960 };
23961
23962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23963 if (obj0) {
23964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23965 if (!SWIG_IsOK(res1)) {
23966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23967 }
23968 arg1 = reinterpret_cast< wxWindow * >(argp1);
23969 }
23970 {
23971 PyThreadState* __tstate = wxPyBeginAllowThreads();
23972 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23973 wxPyEndAllowThreads(__tstate);
23974 if (PyErr_Occurred()) SWIG_fail;
23975 }
23976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23977 return resultobj;
23978 fail:
23979 return NULL;
23980 }
23981
23982
23983 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23984 PyObject *resultobj = 0;
23985 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23986 wxWindow *result = 0 ;
23987 void *argp1 = 0 ;
23988 int res1 = 0 ;
23989 PyObject *swig_obj[1] ;
23990
23991 if (!args) SWIG_fail;
23992 swig_obj[0] = args;
23993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23994 if (!SWIG_IsOK(res1)) {
23995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23996 }
23997 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23998 {
23999 PyThreadState* __tstate = wxPyBeginAllowThreads();
24000 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24001 wxPyEndAllowThreads(__tstate);
24002 if (PyErr_Occurred()) SWIG_fail;
24003 }
24004 {
24005 resultobj = wxPyMake_wxObject(result, (bool)0);
24006 }
24007 return resultobj;
24008 fail:
24009 return NULL;
24010 }
24011
24012
24013 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24014 PyObject *obj;
24015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24016 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24017 return SWIG_Py_Void();
24018 }
24019
24020 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24021 return SWIG_Python_InitShadowInstance(args);
24022 }
24023
24024 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24025 PyObject *resultobj = 0;
24026 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24027 bool arg2 = (bool) true ;
24028 int arg3 = (int) 0 ;
24029 wxActivateEvent *result = 0 ;
24030 int val1 ;
24031 int ecode1 = 0 ;
24032 bool val2 ;
24033 int ecode2 = 0 ;
24034 int val3 ;
24035 int ecode3 = 0 ;
24036 PyObject * obj0 = 0 ;
24037 PyObject * obj1 = 0 ;
24038 PyObject * obj2 = 0 ;
24039 char * kwnames[] = {
24040 (char *) "type",(char *) "active",(char *) "Id", NULL
24041 };
24042
24043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24044 if (obj0) {
24045 ecode1 = SWIG_AsVal_int(obj0, &val1);
24046 if (!SWIG_IsOK(ecode1)) {
24047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24048 }
24049 arg1 = static_cast< wxEventType >(val1);
24050 }
24051 if (obj1) {
24052 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24053 if (!SWIG_IsOK(ecode2)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24055 }
24056 arg2 = static_cast< bool >(val2);
24057 }
24058 if (obj2) {
24059 ecode3 = SWIG_AsVal_int(obj2, &val3);
24060 if (!SWIG_IsOK(ecode3)) {
24061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24062 }
24063 arg3 = static_cast< int >(val3);
24064 }
24065 {
24066 PyThreadState* __tstate = wxPyBeginAllowThreads();
24067 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24079 PyObject *resultobj = 0;
24080 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24081 bool result;
24082 void *argp1 = 0 ;
24083 int res1 = 0 ;
24084 PyObject *swig_obj[1] ;
24085
24086 if (!args) SWIG_fail;
24087 swig_obj[0] = args;
24088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24089 if (!SWIG_IsOK(res1)) {
24090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24091 }
24092 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24093 {
24094 PyThreadState* __tstate = wxPyBeginAllowThreads();
24095 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24096 wxPyEndAllowThreads(__tstate);
24097 if (PyErr_Occurred()) SWIG_fail;
24098 }
24099 {
24100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24101 }
24102 return resultobj;
24103 fail:
24104 return NULL;
24105 }
24106
24107
24108 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24109 PyObject *obj;
24110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24111 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24112 return SWIG_Py_Void();
24113 }
24114
24115 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 return SWIG_Python_InitShadowInstance(args);
24117 }
24118
24119 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj = 0;
24121 int arg1 = (int) 0 ;
24122 wxInitDialogEvent *result = 0 ;
24123 int val1 ;
24124 int ecode1 = 0 ;
24125 PyObject * obj0 = 0 ;
24126 char * kwnames[] = {
24127 (char *) "Id", NULL
24128 };
24129
24130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24131 if (obj0) {
24132 ecode1 = SWIG_AsVal_int(obj0, &val1);
24133 if (!SWIG_IsOK(ecode1)) {
24134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24135 }
24136 arg1 = static_cast< int >(val1);
24137 }
24138 {
24139 PyThreadState* __tstate = wxPyBeginAllowThreads();
24140 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24141 wxPyEndAllowThreads(__tstate);
24142 if (PyErr_Occurred()) SWIG_fail;
24143 }
24144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24145 return resultobj;
24146 fail:
24147 return NULL;
24148 }
24149
24150
24151 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24152 PyObject *obj;
24153 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24154 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24155 return SWIG_Py_Void();
24156 }
24157
24158 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24159 return SWIG_Python_InitShadowInstance(args);
24160 }
24161
24162 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24163 PyObject *resultobj = 0;
24164 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24165 int arg2 = (int) 0 ;
24166 wxMenu *arg3 = (wxMenu *) NULL ;
24167 wxMenuEvent *result = 0 ;
24168 int val1 ;
24169 int ecode1 = 0 ;
24170 int val2 ;
24171 int ecode2 = 0 ;
24172 void *argp3 = 0 ;
24173 int res3 = 0 ;
24174 PyObject * obj0 = 0 ;
24175 PyObject * obj1 = 0 ;
24176 PyObject * obj2 = 0 ;
24177 char * kwnames[] = {
24178 (char *) "type",(char *) "winid",(char *) "menu", NULL
24179 };
24180
24181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24182 if (obj0) {
24183 ecode1 = SWIG_AsVal_int(obj0, &val1);
24184 if (!SWIG_IsOK(ecode1)) {
24185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24186 }
24187 arg1 = static_cast< wxEventType >(val1);
24188 }
24189 if (obj1) {
24190 ecode2 = SWIG_AsVal_int(obj1, &val2);
24191 if (!SWIG_IsOK(ecode2)) {
24192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24193 }
24194 arg2 = static_cast< int >(val2);
24195 }
24196 if (obj2) {
24197 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24198 if (!SWIG_IsOK(res3)) {
24199 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24200 }
24201 arg3 = reinterpret_cast< wxMenu * >(argp3);
24202 }
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24217 PyObject *resultobj = 0;
24218 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24219 int result;
24220 void *argp1 = 0 ;
24221 int res1 = 0 ;
24222 PyObject *swig_obj[1] ;
24223
24224 if (!args) SWIG_fail;
24225 swig_obj[0] = args;
24226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24229 }
24230 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 resultobj = SWIG_From_int(static_cast< int >(result));
24238 return resultobj;
24239 fail:
24240 return NULL;
24241 }
24242
24243
24244 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24245 PyObject *resultobj = 0;
24246 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24247 bool result;
24248 void *argp1 = 0 ;
24249 int res1 = 0 ;
24250 PyObject *swig_obj[1] ;
24251
24252 if (!args) SWIG_fail;
24253 swig_obj[0] = args;
24254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24255 if (!SWIG_IsOK(res1)) {
24256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24257 }
24258 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24259 {
24260 PyThreadState* __tstate = wxPyBeginAllowThreads();
24261 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24262 wxPyEndAllowThreads(__tstate);
24263 if (PyErr_Occurred()) SWIG_fail;
24264 }
24265 {
24266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24267 }
24268 return resultobj;
24269 fail:
24270 return NULL;
24271 }
24272
24273
24274 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24275 PyObject *resultobj = 0;
24276 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24277 wxMenu *result = 0 ;
24278 void *argp1 = 0 ;
24279 int res1 = 0 ;
24280 PyObject *swig_obj[1] ;
24281
24282 if (!args) SWIG_fail;
24283 swig_obj[0] = args;
24284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24285 if (!SWIG_IsOK(res1)) {
24286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24287 }
24288 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24289 {
24290 PyThreadState* __tstate = wxPyBeginAllowThreads();
24291 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24292 wxPyEndAllowThreads(__tstate);
24293 if (PyErr_Occurred()) SWIG_fail;
24294 }
24295 {
24296 resultobj = wxPyMake_wxObject(result, (bool)0);
24297 }
24298 return resultobj;
24299 fail:
24300 return NULL;
24301 }
24302
24303
24304 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24305 PyObject *obj;
24306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24307 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24308 return SWIG_Py_Void();
24309 }
24310
24311 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24312 return SWIG_Python_InitShadowInstance(args);
24313 }
24314
24315 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24316 PyObject *resultobj = 0;
24317 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24318 int arg2 = (int) 0 ;
24319 wxCloseEvent *result = 0 ;
24320 int val1 ;
24321 int ecode1 = 0 ;
24322 int val2 ;
24323 int ecode2 = 0 ;
24324 PyObject * obj0 = 0 ;
24325 PyObject * obj1 = 0 ;
24326 char * kwnames[] = {
24327 (char *) "type",(char *) "winid", NULL
24328 };
24329
24330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24331 if (obj0) {
24332 ecode1 = SWIG_AsVal_int(obj0, &val1);
24333 if (!SWIG_IsOK(ecode1)) {
24334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24335 }
24336 arg1 = static_cast< wxEventType >(val1);
24337 }
24338 if (obj1) {
24339 ecode2 = SWIG_AsVal_int(obj1, &val2);
24340 if (!SWIG_IsOK(ecode2)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24342 }
24343 arg2 = static_cast< int >(val2);
24344 }
24345 {
24346 PyThreadState* __tstate = wxPyBeginAllowThreads();
24347 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj = 0;
24360 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24361 bool arg2 ;
24362 void *argp1 = 0 ;
24363 int res1 = 0 ;
24364 bool val2 ;
24365 int ecode2 = 0 ;
24366 PyObject * obj0 = 0 ;
24367 PyObject * obj1 = 0 ;
24368 char * kwnames[] = {
24369 (char *) "self",(char *) "logOff", NULL
24370 };
24371
24372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24374 if (!SWIG_IsOK(res1)) {
24375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24376 }
24377 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24378 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24379 if (!SWIG_IsOK(ecode2)) {
24380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24381 }
24382 arg2 = static_cast< bool >(val2);
24383 {
24384 PyThreadState* __tstate = wxPyBeginAllowThreads();
24385 (arg1)->SetLoggingOff(arg2);
24386 wxPyEndAllowThreads(__tstate);
24387 if (PyErr_Occurred()) SWIG_fail;
24388 }
24389 resultobj = SWIG_Py_Void();
24390 return resultobj;
24391 fail:
24392 return NULL;
24393 }
24394
24395
24396 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24397 PyObject *resultobj = 0;
24398 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24399 bool result;
24400 void *argp1 = 0 ;
24401 int res1 = 0 ;
24402 PyObject *swig_obj[1] ;
24403
24404 if (!args) SWIG_fail;
24405 swig_obj[0] = args;
24406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24407 if (!SWIG_IsOK(res1)) {
24408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24409 }
24410 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24411 {
24412 PyThreadState* __tstate = wxPyBeginAllowThreads();
24413 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24414 wxPyEndAllowThreads(__tstate);
24415 if (PyErr_Occurred()) SWIG_fail;
24416 }
24417 {
24418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24419 }
24420 return resultobj;
24421 fail:
24422 return NULL;
24423 }
24424
24425
24426 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24427 PyObject *resultobj = 0;
24428 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24429 bool arg2 = (bool) true ;
24430 void *argp1 = 0 ;
24431 int res1 = 0 ;
24432 bool val2 ;
24433 int ecode2 = 0 ;
24434 PyObject * obj0 = 0 ;
24435 PyObject * obj1 = 0 ;
24436 char * kwnames[] = {
24437 (char *) "self",(char *) "veto", NULL
24438 };
24439
24440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24442 if (!SWIG_IsOK(res1)) {
24443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24444 }
24445 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24446 if (obj1) {
24447 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24448 if (!SWIG_IsOK(ecode2)) {
24449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24450 }
24451 arg2 = static_cast< bool >(val2);
24452 }
24453 {
24454 PyThreadState* __tstate = wxPyBeginAllowThreads();
24455 (arg1)->Veto(arg2);
24456 wxPyEndAllowThreads(__tstate);
24457 if (PyErr_Occurred()) SWIG_fail;
24458 }
24459 resultobj = SWIG_Py_Void();
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24467 PyObject *resultobj = 0;
24468 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24469 bool result;
24470 void *argp1 = 0 ;
24471 int res1 = 0 ;
24472 PyObject *swig_obj[1] ;
24473
24474 if (!args) SWIG_fail;
24475 swig_obj[0] = args;
24476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24477 if (!SWIG_IsOK(res1)) {
24478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24479 }
24480 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24484 wxPyEndAllowThreads(__tstate);
24485 if (PyErr_Occurred()) SWIG_fail;
24486 }
24487 {
24488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24489 }
24490 return resultobj;
24491 fail:
24492 return NULL;
24493 }
24494
24495
24496 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24497 PyObject *resultobj = 0;
24498 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24499 bool arg2 ;
24500 void *argp1 = 0 ;
24501 int res1 = 0 ;
24502 bool val2 ;
24503 int ecode2 = 0 ;
24504 PyObject * obj0 = 0 ;
24505 PyObject * obj1 = 0 ;
24506 char * kwnames[] = {
24507 (char *) "self",(char *) "canVeto", NULL
24508 };
24509
24510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24512 if (!SWIG_IsOK(res1)) {
24513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24514 }
24515 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24516 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24517 if (!SWIG_IsOK(ecode2)) {
24518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24519 }
24520 arg2 = static_cast< bool >(val2);
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 (arg1)->SetCanVeto(arg2);
24524 wxPyEndAllowThreads(__tstate);
24525 if (PyErr_Occurred()) SWIG_fail;
24526 }
24527 resultobj = SWIG_Py_Void();
24528 return resultobj;
24529 fail:
24530 return NULL;
24531 }
24532
24533
24534 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24535 PyObject *resultobj = 0;
24536 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24537 bool result;
24538 void *argp1 = 0 ;
24539 int res1 = 0 ;
24540 PyObject *swig_obj[1] ;
24541
24542 if (!args) SWIG_fail;
24543 swig_obj[0] = args;
24544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24545 if (!SWIG_IsOK(res1)) {
24546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24547 }
24548 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24549 {
24550 PyThreadState* __tstate = wxPyBeginAllowThreads();
24551 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24552 wxPyEndAllowThreads(__tstate);
24553 if (PyErr_Occurred()) SWIG_fail;
24554 }
24555 {
24556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24557 }
24558 return resultobj;
24559 fail:
24560 return NULL;
24561 }
24562
24563
24564 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24565 PyObject *obj;
24566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24567 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24568 return SWIG_Py_Void();
24569 }
24570
24571 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24572 return SWIG_Python_InitShadowInstance(args);
24573 }
24574
24575 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj = 0;
24577 int arg1 = (int) 0 ;
24578 bool arg2 = (bool) false ;
24579 wxShowEvent *result = 0 ;
24580 int val1 ;
24581 int ecode1 = 0 ;
24582 bool val2 ;
24583 int ecode2 = 0 ;
24584 PyObject * obj0 = 0 ;
24585 PyObject * obj1 = 0 ;
24586 char * kwnames[] = {
24587 (char *) "winid",(char *) "show", NULL
24588 };
24589
24590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24591 if (obj0) {
24592 ecode1 = SWIG_AsVal_int(obj0, &val1);
24593 if (!SWIG_IsOK(ecode1)) {
24594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24595 }
24596 arg1 = static_cast< int >(val1);
24597 }
24598 if (obj1) {
24599 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24600 if (!SWIG_IsOK(ecode2)) {
24601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24602 }
24603 arg2 = static_cast< bool >(val2);
24604 }
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24608 wxPyEndAllowThreads(__tstate);
24609 if (PyErr_Occurred()) SWIG_fail;
24610 }
24611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj = 0;
24620 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24621 bool arg2 ;
24622 void *argp1 = 0 ;
24623 int res1 = 0 ;
24624 bool val2 ;
24625 int ecode2 = 0 ;
24626 PyObject * obj0 = 0 ;
24627 PyObject * obj1 = 0 ;
24628 char * kwnames[] = {
24629 (char *) "self",(char *) "show", NULL
24630 };
24631
24632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24634 if (!SWIG_IsOK(res1)) {
24635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24636 }
24637 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24639 if (!SWIG_IsOK(ecode2)) {
24640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24641 }
24642 arg2 = static_cast< bool >(val2);
24643 {
24644 PyThreadState* __tstate = wxPyBeginAllowThreads();
24645 (arg1)->SetShow(arg2);
24646 wxPyEndAllowThreads(__tstate);
24647 if (PyErr_Occurred()) SWIG_fail;
24648 }
24649 resultobj = SWIG_Py_Void();
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24657 PyObject *resultobj = 0;
24658 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24659 bool result;
24660 void *argp1 = 0 ;
24661 int res1 = 0 ;
24662 PyObject *swig_obj[1] ;
24663
24664 if (!args) SWIG_fail;
24665 swig_obj[0] = args;
24666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24667 if (!SWIG_IsOK(res1)) {
24668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24669 }
24670 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 {
24678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24679 }
24680 return resultobj;
24681 fail:
24682 return NULL;
24683 }
24684
24685
24686 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24687 PyObject *obj;
24688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24689 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24690 return SWIG_Py_Void();
24691 }
24692
24693 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24694 return SWIG_Python_InitShadowInstance(args);
24695 }
24696
24697 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24698 PyObject *resultobj = 0;
24699 int arg1 = (int) 0 ;
24700 bool arg2 = (bool) true ;
24701 wxIconizeEvent *result = 0 ;
24702 int val1 ;
24703 int ecode1 = 0 ;
24704 bool val2 ;
24705 int ecode2 = 0 ;
24706 PyObject * obj0 = 0 ;
24707 PyObject * obj1 = 0 ;
24708 char * kwnames[] = {
24709 (char *) "id",(char *) "iconized", NULL
24710 };
24711
24712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24713 if (obj0) {
24714 ecode1 = SWIG_AsVal_int(obj0, &val1);
24715 if (!SWIG_IsOK(ecode1)) {
24716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24717 }
24718 arg1 = static_cast< int >(val1);
24719 }
24720 if (obj1) {
24721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24722 if (!SWIG_IsOK(ecode2)) {
24723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24724 }
24725 arg2 = static_cast< bool >(val2);
24726 }
24727 {
24728 PyThreadState* __tstate = wxPyBeginAllowThreads();
24729 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24730 wxPyEndAllowThreads(__tstate);
24731 if (PyErr_Occurred()) SWIG_fail;
24732 }
24733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24734 return resultobj;
24735 fail:
24736 return NULL;
24737 }
24738
24739
24740 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24741 PyObject *resultobj = 0;
24742 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24743 bool result;
24744 void *argp1 = 0 ;
24745 int res1 = 0 ;
24746 PyObject *swig_obj[1] ;
24747
24748 if (!args) SWIG_fail;
24749 swig_obj[0] = args;
24750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24751 if (!SWIG_IsOK(res1)) {
24752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24753 }
24754 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24755 {
24756 PyThreadState* __tstate = wxPyBeginAllowThreads();
24757 result = (bool)(arg1)->Iconized();
24758 wxPyEndAllowThreads(__tstate);
24759 if (PyErr_Occurred()) SWIG_fail;
24760 }
24761 {
24762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24763 }
24764 return resultobj;
24765 fail:
24766 return NULL;
24767 }
24768
24769
24770 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24771 PyObject *obj;
24772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24773 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24774 return SWIG_Py_Void();
24775 }
24776
24777 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24778 return SWIG_Python_InitShadowInstance(args);
24779 }
24780
24781 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24782 PyObject *resultobj = 0;
24783 int arg1 = (int) 0 ;
24784 wxMaximizeEvent *result = 0 ;
24785 int val1 ;
24786 int ecode1 = 0 ;
24787 PyObject * obj0 = 0 ;
24788 char * kwnames[] = {
24789 (char *) "id", NULL
24790 };
24791
24792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24793 if (obj0) {
24794 ecode1 = SWIG_AsVal_int(obj0, &val1);
24795 if (!SWIG_IsOK(ecode1)) {
24796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24797 }
24798 arg1 = static_cast< int >(val1);
24799 }
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24807 return resultobj;
24808 fail:
24809 return NULL;
24810 }
24811
24812
24813 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24814 PyObject *obj;
24815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24816 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24817 return SWIG_Py_Void();
24818 }
24819
24820 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 return SWIG_Python_InitShadowInstance(args);
24822 }
24823
24824 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24825 PyObject *resultobj = 0;
24826 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24827 wxPoint result;
24828 void *argp1 = 0 ;
24829 int res1 = 0 ;
24830 PyObject *swig_obj[1] ;
24831
24832 if (!args) SWIG_fail;
24833 swig_obj[0] = args;
24834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24835 if (!SWIG_IsOK(res1)) {
24836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24837 }
24838 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 result = (arg1)->GetPosition();
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24853 PyObject *resultobj = 0;
24854 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24855 int result;
24856 void *argp1 = 0 ;
24857 int res1 = 0 ;
24858 PyObject *swig_obj[1] ;
24859
24860 if (!args) SWIG_fail;
24861 swig_obj[0] = args;
24862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24863 if (!SWIG_IsOK(res1)) {
24864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24865 }
24866 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24867 {
24868 PyThreadState* __tstate = wxPyBeginAllowThreads();
24869 result = (int)(arg1)->GetNumberOfFiles();
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 resultobj = SWIG_From_int(static_cast< int >(result));
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24881 PyObject *resultobj = 0;
24882 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24883 PyObject *result = 0 ;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 PyObject *swig_obj[1] ;
24887
24888 if (!args) SWIG_fail;
24889 swig_obj[0] = args;
24890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24893 }
24894 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24895 {
24896 PyThreadState* __tstate = wxPyBeginAllowThreads();
24897 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24898 wxPyEndAllowThreads(__tstate);
24899 if (PyErr_Occurred()) SWIG_fail;
24900 }
24901 resultobj = result;
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24909 PyObject *obj;
24910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24911 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24912 return SWIG_Py_Void();
24913 }
24914
24915 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24916 PyObject *resultobj = 0;
24917 int arg1 = (int) 0 ;
24918 wxUpdateUIEvent *result = 0 ;
24919 int val1 ;
24920 int ecode1 = 0 ;
24921 PyObject * obj0 = 0 ;
24922 char * kwnames[] = {
24923 (char *) "commandId", NULL
24924 };
24925
24926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24927 if (obj0) {
24928 ecode1 = SWIG_AsVal_int(obj0, &val1);
24929 if (!SWIG_IsOK(ecode1)) {
24930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24931 }
24932 arg1 = static_cast< int >(val1);
24933 }
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24937 wxPyEndAllowThreads(__tstate);
24938 if (PyErr_Occurred()) SWIG_fail;
24939 }
24940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24941 return resultobj;
24942 fail:
24943 return NULL;
24944 }
24945
24946
24947 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24948 PyObject *resultobj = 0;
24949 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24950 bool result;
24951 void *argp1 = 0 ;
24952 int res1 = 0 ;
24953 PyObject *swig_obj[1] ;
24954
24955 if (!args) SWIG_fail;
24956 swig_obj[0] = args;
24957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24958 if (!SWIG_IsOK(res1)) {
24959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24960 }
24961 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24962 {
24963 PyThreadState* __tstate = wxPyBeginAllowThreads();
24964 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24965 wxPyEndAllowThreads(__tstate);
24966 if (PyErr_Occurred()) SWIG_fail;
24967 }
24968 {
24969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24970 }
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24978 PyObject *resultobj = 0;
24979 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24980 bool result;
24981 void *argp1 = 0 ;
24982 int res1 = 0 ;
24983 PyObject *swig_obj[1] ;
24984
24985 if (!args) SWIG_fail;
24986 swig_obj[0] = args;
24987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24988 if (!SWIG_IsOK(res1)) {
24989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24990 }
24991 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 {
24999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25000 }
25001 return resultobj;
25002 fail:
25003 return NULL;
25004 }
25005
25006
25007 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25008 PyObject *resultobj = 0;
25009 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25010 bool result;
25011 void *argp1 = 0 ;
25012 int res1 = 0 ;
25013 PyObject *swig_obj[1] ;
25014
25015 if (!args) SWIG_fail;
25016 swig_obj[0] = args;
25017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25018 if (!SWIG_IsOK(res1)) {
25019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25020 }
25021 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25022 {
25023 PyThreadState* __tstate = wxPyBeginAllowThreads();
25024 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 {
25029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25030 }
25031 return resultobj;
25032 fail:
25033 return NULL;
25034 }
25035
25036
25037 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25038 PyObject *resultobj = 0;
25039 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25040 wxString result;
25041 void *argp1 = 0 ;
25042 int res1 = 0 ;
25043 PyObject *swig_obj[1] ;
25044
25045 if (!args) SWIG_fail;
25046 swig_obj[0] = args;
25047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25048 if (!SWIG_IsOK(res1)) {
25049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25050 }
25051 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25052 {
25053 PyThreadState* __tstate = wxPyBeginAllowThreads();
25054 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25055 wxPyEndAllowThreads(__tstate);
25056 if (PyErr_Occurred()) SWIG_fail;
25057 }
25058 {
25059 #if wxUSE_UNICODE
25060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25061 #else
25062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25063 #endif
25064 }
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25072 PyObject *resultobj = 0;
25073 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25074 bool result;
25075 void *argp1 = 0 ;
25076 int res1 = 0 ;
25077 PyObject *swig_obj[1] ;
25078
25079 if (!args) SWIG_fail;
25080 swig_obj[0] = args;
25081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25082 if (!SWIG_IsOK(res1)) {
25083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25084 }
25085 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25086 {
25087 PyThreadState* __tstate = wxPyBeginAllowThreads();
25088 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25089 wxPyEndAllowThreads(__tstate);
25090 if (PyErr_Occurred()) SWIG_fail;
25091 }
25092 {
25093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25094 }
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25102 PyObject *resultobj = 0;
25103 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25104 bool result;
25105 void *argp1 = 0 ;
25106 int res1 = 0 ;
25107 PyObject *swig_obj[1] ;
25108
25109 if (!args) SWIG_fail;
25110 swig_obj[0] = args;
25111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25112 if (!SWIG_IsOK(res1)) {
25113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25114 }
25115 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25116 {
25117 PyThreadState* __tstate = wxPyBeginAllowThreads();
25118 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25132 PyObject *resultobj = 0;
25133 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25134 bool result;
25135 void *argp1 = 0 ;
25136 int res1 = 0 ;
25137 PyObject *swig_obj[1] ;
25138
25139 if (!args) SWIG_fail;
25140 swig_obj[0] = args;
25141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25142 if (!SWIG_IsOK(res1)) {
25143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25144 }
25145 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25146 {
25147 PyThreadState* __tstate = wxPyBeginAllowThreads();
25148 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25154 }
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25162 PyObject *resultobj = 0;
25163 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25164 bool result;
25165 void *argp1 = 0 ;
25166 int res1 = 0 ;
25167 PyObject *swig_obj[1] ;
25168
25169 if (!args) SWIG_fail;
25170 swig_obj[0] = args;
25171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25172 if (!SWIG_IsOK(res1)) {
25173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25174 }
25175 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25176 {
25177 PyThreadState* __tstate = wxPyBeginAllowThreads();
25178 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25179 wxPyEndAllowThreads(__tstate);
25180 if (PyErr_Occurred()) SWIG_fail;
25181 }
25182 {
25183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25184 }
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25192 PyObject *resultobj = 0;
25193 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25194 bool arg2 ;
25195 void *argp1 = 0 ;
25196 int res1 = 0 ;
25197 bool val2 ;
25198 int ecode2 = 0 ;
25199 PyObject * obj0 = 0 ;
25200 PyObject * obj1 = 0 ;
25201 char * kwnames[] = {
25202 (char *) "self",(char *) "check", NULL
25203 };
25204
25205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25207 if (!SWIG_IsOK(res1)) {
25208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25209 }
25210 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25211 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25212 if (!SWIG_IsOK(ecode2)) {
25213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25214 }
25215 arg2 = static_cast< bool >(val2);
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 (arg1)->Check(arg2);
25219 wxPyEndAllowThreads(__tstate);
25220 if (PyErr_Occurred()) SWIG_fail;
25221 }
25222 resultobj = SWIG_Py_Void();
25223 return resultobj;
25224 fail:
25225 return NULL;
25226 }
25227
25228
25229 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25230 PyObject *resultobj = 0;
25231 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25232 bool arg2 ;
25233 void *argp1 = 0 ;
25234 int res1 = 0 ;
25235 bool val2 ;
25236 int ecode2 = 0 ;
25237 PyObject * obj0 = 0 ;
25238 PyObject * obj1 = 0 ;
25239 char * kwnames[] = {
25240 (char *) "self",(char *) "enable", NULL
25241 };
25242
25243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25245 if (!SWIG_IsOK(res1)) {
25246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25247 }
25248 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25249 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25250 if (!SWIG_IsOK(ecode2)) {
25251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25252 }
25253 arg2 = static_cast< bool >(val2);
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 (arg1)->Enable(arg2);
25257 wxPyEndAllowThreads(__tstate);
25258 if (PyErr_Occurred()) SWIG_fail;
25259 }
25260 resultobj = SWIG_Py_Void();
25261 return resultobj;
25262 fail:
25263 return NULL;
25264 }
25265
25266
25267 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25268 PyObject *resultobj = 0;
25269 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25270 bool arg2 ;
25271 void *argp1 = 0 ;
25272 int res1 = 0 ;
25273 bool val2 ;
25274 int ecode2 = 0 ;
25275 PyObject * obj0 = 0 ;
25276 PyObject * obj1 = 0 ;
25277 char * kwnames[] = {
25278 (char *) "self",(char *) "show", NULL
25279 };
25280
25281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25283 if (!SWIG_IsOK(res1)) {
25284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25285 }
25286 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25287 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25288 if (!SWIG_IsOK(ecode2)) {
25289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25290 }
25291 arg2 = static_cast< bool >(val2);
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 (arg1)->Show(arg2);
25295 wxPyEndAllowThreads(__tstate);
25296 if (PyErr_Occurred()) SWIG_fail;
25297 }
25298 resultobj = SWIG_Py_Void();
25299 return resultobj;
25300 fail:
25301 return NULL;
25302 }
25303
25304
25305 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25306 PyObject *resultobj = 0;
25307 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25308 wxString *arg2 = 0 ;
25309 void *argp1 = 0 ;
25310 int res1 = 0 ;
25311 bool temp2 = false ;
25312 PyObject * obj0 = 0 ;
25313 PyObject * obj1 = 0 ;
25314 char * kwnames[] = {
25315 (char *) "self",(char *) "text", NULL
25316 };
25317
25318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25320 if (!SWIG_IsOK(res1)) {
25321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25322 }
25323 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25324 {
25325 arg2 = wxString_in_helper(obj1);
25326 if (arg2 == NULL) SWIG_fail;
25327 temp2 = true;
25328 }
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 (arg1)->SetText((wxString const &)*arg2);
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 resultobj = SWIG_Py_Void();
25336 {
25337 if (temp2)
25338 delete arg2;
25339 }
25340 return resultobj;
25341 fail:
25342 {
25343 if (temp2)
25344 delete arg2;
25345 }
25346 return NULL;
25347 }
25348
25349
25350 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj = 0;
25352 long arg1 ;
25353 long val1 ;
25354 int ecode1 = 0 ;
25355 PyObject * obj0 = 0 ;
25356 char * kwnames[] = {
25357 (char *) "updateInterval", NULL
25358 };
25359
25360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25361 ecode1 = SWIG_AsVal_long(obj0, &val1);
25362 if (!SWIG_IsOK(ecode1)) {
25363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25364 }
25365 arg1 = static_cast< long >(val1);
25366 {
25367 PyThreadState* __tstate = wxPyBeginAllowThreads();
25368 wxUpdateUIEvent::SetUpdateInterval(arg1);
25369 wxPyEndAllowThreads(__tstate);
25370 if (PyErr_Occurred()) SWIG_fail;
25371 }
25372 resultobj = SWIG_Py_Void();
25373 return resultobj;
25374 fail:
25375 return NULL;
25376 }
25377
25378
25379 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25380 PyObject *resultobj = 0;
25381 long result;
25382
25383 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 resultobj = SWIG_From_long(static_cast< long >(result));
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj = 0;
25399 wxWindow *arg1 = (wxWindow *) 0 ;
25400 bool result;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 PyObject * obj0 = 0 ;
25404 char * kwnames[] = {
25405 (char *) "win", NULL
25406 };
25407
25408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25410 if (!SWIG_IsOK(res1)) {
25411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25412 }
25413 arg1 = reinterpret_cast< wxWindow * >(argp1);
25414 {
25415 PyThreadState* __tstate = wxPyBeginAllowThreads();
25416 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25417 wxPyEndAllowThreads(__tstate);
25418 if (PyErr_Occurred()) SWIG_fail;
25419 }
25420 {
25421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25422 }
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *resultobj = 0;
25431
25432 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25433 {
25434 PyThreadState* __tstate = wxPyBeginAllowThreads();
25435 wxUpdateUIEvent::ResetUpdateTime();
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 resultobj = SWIG_Py_Void();
25440 return resultobj;
25441 fail:
25442 return NULL;
25443 }
25444
25445
25446 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25447 PyObject *resultobj = 0;
25448 wxUpdateUIMode arg1 ;
25449 int val1 ;
25450 int ecode1 = 0 ;
25451 PyObject * obj0 = 0 ;
25452 char * kwnames[] = {
25453 (char *) "mode", NULL
25454 };
25455
25456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25457 ecode1 = SWIG_AsVal_int(obj0, &val1);
25458 if (!SWIG_IsOK(ecode1)) {
25459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25460 }
25461 arg1 = static_cast< wxUpdateUIMode >(val1);
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 wxUpdateUIEvent::SetMode(arg1);
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 resultobj = SWIG_Py_Void();
25469 return resultobj;
25470 fail:
25471 return NULL;
25472 }
25473
25474
25475 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25476 PyObject *resultobj = 0;
25477 wxUpdateUIMode result;
25478
25479 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25480 {
25481 PyThreadState* __tstate = wxPyBeginAllowThreads();
25482 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25483 wxPyEndAllowThreads(__tstate);
25484 if (PyErr_Occurred()) SWIG_fail;
25485 }
25486 resultobj = SWIG_From_int(static_cast< int >(result));
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *obj;
25495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25496 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25497 return SWIG_Py_Void();
25498 }
25499
25500 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25501 return SWIG_Python_InitShadowInstance(args);
25502 }
25503
25504 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25505 PyObject *resultobj = 0;
25506 wxSysColourChangedEvent *result = 0 ;
25507
25508 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25523 PyObject *obj;
25524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25525 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25526 return SWIG_Py_Void();
25527 }
25528
25529 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25530 return SWIG_Python_InitShadowInstance(args);
25531 }
25532
25533 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25534 PyObject *resultobj = 0;
25535 int arg1 = (int) 0 ;
25536 wxWindow *arg2 = (wxWindow *) NULL ;
25537 wxMouseCaptureChangedEvent *result = 0 ;
25538 int val1 ;
25539 int ecode1 = 0 ;
25540 void *argp2 = 0 ;
25541 int res2 = 0 ;
25542 PyObject * obj0 = 0 ;
25543 PyObject * obj1 = 0 ;
25544 char * kwnames[] = {
25545 (char *) "winid",(char *) "gainedCapture", NULL
25546 };
25547
25548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25549 if (obj0) {
25550 ecode1 = SWIG_AsVal_int(obj0, &val1);
25551 if (!SWIG_IsOK(ecode1)) {
25552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25553 }
25554 arg1 = static_cast< int >(val1);
25555 }
25556 if (obj1) {
25557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25558 if (!SWIG_IsOK(res2)) {
25559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25560 }
25561 arg2 = reinterpret_cast< wxWindow * >(argp2);
25562 }
25563 {
25564 PyThreadState* __tstate = wxPyBeginAllowThreads();
25565 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25566 wxPyEndAllowThreads(__tstate);
25567 if (PyErr_Occurred()) SWIG_fail;
25568 }
25569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25577 PyObject *resultobj = 0;
25578 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25579 wxWindow *result = 0 ;
25580 void *argp1 = 0 ;
25581 int res1 = 0 ;
25582 PyObject *swig_obj[1] ;
25583
25584 if (!args) SWIG_fail;
25585 swig_obj[0] = args;
25586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25587 if (!SWIG_IsOK(res1)) {
25588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25589 }
25590 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25594 wxPyEndAllowThreads(__tstate);
25595 if (PyErr_Occurred()) SWIG_fail;
25596 }
25597 {
25598 resultobj = wxPyMake_wxObject(result, (bool)0);
25599 }
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25607 PyObject *obj;
25608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25609 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25610 return SWIG_Py_Void();
25611 }
25612
25613 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25614 return SWIG_Python_InitShadowInstance(args);
25615 }
25616
25617 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25618 PyObject *resultobj = 0;
25619 int arg1 = (int) 0 ;
25620 wxMouseCaptureLostEvent *result = 0 ;
25621 int val1 ;
25622 int ecode1 = 0 ;
25623 PyObject * obj0 = 0 ;
25624 char * kwnames[] = {
25625 (char *) "winid", NULL
25626 };
25627
25628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25629 if (obj0) {
25630 ecode1 = SWIG_AsVal_int(obj0, &val1);
25631 if (!SWIG_IsOK(ecode1)) {
25632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25633 }
25634 arg1 = static_cast< int >(val1);
25635 }
25636 {
25637 PyThreadState* __tstate = wxPyBeginAllowThreads();
25638 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25639 wxPyEndAllowThreads(__tstate);
25640 if (PyErr_Occurred()) SWIG_fail;
25641 }
25642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 PyObject *obj;
25651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25652 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25653 return SWIG_Py_Void();
25654 }
25655
25656 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 return SWIG_Python_InitShadowInstance(args);
25658 }
25659
25660 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25661 PyObject *resultobj = 0;
25662 wxDisplayChangedEvent *result = 0 ;
25663
25664 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25665 {
25666 PyThreadState* __tstate = wxPyBeginAllowThreads();
25667 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25668 wxPyEndAllowThreads(__tstate);
25669 if (PyErr_Occurred()) SWIG_fail;
25670 }
25671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25672 return resultobj;
25673 fail:
25674 return NULL;
25675 }
25676
25677
25678 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25679 PyObject *obj;
25680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25681 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25682 return SWIG_Py_Void();
25683 }
25684
25685 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 return SWIG_Python_InitShadowInstance(args);
25687 }
25688
25689 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25690 PyObject *resultobj = 0;
25691 int arg1 = (int) 0 ;
25692 wxPaletteChangedEvent *result = 0 ;
25693 int val1 ;
25694 int ecode1 = 0 ;
25695 PyObject * obj0 = 0 ;
25696 char * kwnames[] = {
25697 (char *) "id", NULL
25698 };
25699
25700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25701 if (obj0) {
25702 ecode1 = SWIG_AsVal_int(obj0, &val1);
25703 if (!SWIG_IsOK(ecode1)) {
25704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25705 }
25706 arg1 = static_cast< int >(val1);
25707 }
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25722 PyObject *resultobj = 0;
25723 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25724 wxWindow *arg2 = (wxWindow *) 0 ;
25725 void *argp1 = 0 ;
25726 int res1 = 0 ;
25727 void *argp2 = 0 ;
25728 int res2 = 0 ;
25729 PyObject * obj0 = 0 ;
25730 PyObject * obj1 = 0 ;
25731 char * kwnames[] = {
25732 (char *) "self",(char *) "win", NULL
25733 };
25734
25735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25737 if (!SWIG_IsOK(res1)) {
25738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25739 }
25740 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25741 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25742 if (!SWIG_IsOK(res2)) {
25743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25744 }
25745 arg2 = reinterpret_cast< wxWindow * >(argp2);
25746 {
25747 PyThreadState* __tstate = wxPyBeginAllowThreads();
25748 (arg1)->SetChangedWindow(arg2);
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 resultobj = SWIG_Py_Void();
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25760 PyObject *resultobj = 0;
25761 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25762 wxWindow *result = 0 ;
25763 void *argp1 = 0 ;
25764 int res1 = 0 ;
25765 PyObject *swig_obj[1] ;
25766
25767 if (!args) SWIG_fail;
25768 swig_obj[0] = args;
25769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25772 }
25773 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25774 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 result = (wxWindow *)(arg1)->GetChangedWindow();
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 {
25781 resultobj = wxPyMake_wxObject(result, (bool)0);
25782 }
25783 return resultobj;
25784 fail:
25785 return NULL;
25786 }
25787
25788
25789 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25790 PyObject *obj;
25791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25792 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25793 return SWIG_Py_Void();
25794 }
25795
25796 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25797 return SWIG_Python_InitShadowInstance(args);
25798 }
25799
25800 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25801 PyObject *resultobj = 0;
25802 int arg1 = (int) 0 ;
25803 wxQueryNewPaletteEvent *result = 0 ;
25804 int val1 ;
25805 int ecode1 = 0 ;
25806 PyObject * obj0 = 0 ;
25807 char * kwnames[] = {
25808 (char *) "winid", NULL
25809 };
25810
25811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25812 if (obj0) {
25813 ecode1 = SWIG_AsVal_int(obj0, &val1);
25814 if (!SWIG_IsOK(ecode1)) {
25815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25816 }
25817 arg1 = static_cast< int >(val1);
25818 }
25819 {
25820 PyThreadState* __tstate = wxPyBeginAllowThreads();
25821 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25822 wxPyEndAllowThreads(__tstate);
25823 if (PyErr_Occurred()) SWIG_fail;
25824 }
25825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25826 return resultobj;
25827 fail:
25828 return NULL;
25829 }
25830
25831
25832 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25833 PyObject *resultobj = 0;
25834 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25835 bool arg2 ;
25836 void *argp1 = 0 ;
25837 int res1 = 0 ;
25838 bool val2 ;
25839 int ecode2 = 0 ;
25840 PyObject * obj0 = 0 ;
25841 PyObject * obj1 = 0 ;
25842 char * kwnames[] = {
25843 (char *) "self",(char *) "realized", NULL
25844 };
25845
25846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25848 if (!SWIG_IsOK(res1)) {
25849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25850 }
25851 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25852 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25853 if (!SWIG_IsOK(ecode2)) {
25854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25855 }
25856 arg2 = static_cast< bool >(val2);
25857 {
25858 PyThreadState* __tstate = wxPyBeginAllowThreads();
25859 (arg1)->SetPaletteRealized(arg2);
25860 wxPyEndAllowThreads(__tstate);
25861 if (PyErr_Occurred()) SWIG_fail;
25862 }
25863 resultobj = SWIG_Py_Void();
25864 return resultobj;
25865 fail:
25866 return NULL;
25867 }
25868
25869
25870 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25871 PyObject *resultobj = 0;
25872 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25873 bool result;
25874 void *argp1 = 0 ;
25875 int res1 = 0 ;
25876 PyObject *swig_obj[1] ;
25877
25878 if (!args) SWIG_fail;
25879 swig_obj[0] = args;
25880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25881 if (!SWIG_IsOK(res1)) {
25882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25883 }
25884 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25885 {
25886 PyThreadState* __tstate = wxPyBeginAllowThreads();
25887 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25888 wxPyEndAllowThreads(__tstate);
25889 if (PyErr_Occurred()) SWIG_fail;
25890 }
25891 {
25892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25893 }
25894 return resultobj;
25895 fail:
25896 return NULL;
25897 }
25898
25899
25900 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25901 PyObject *obj;
25902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25903 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25904 return SWIG_Py_Void();
25905 }
25906
25907 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25908 return SWIG_Python_InitShadowInstance(args);
25909 }
25910
25911 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25912 PyObject *resultobj = 0;
25913 wxNavigationKeyEvent *result = 0 ;
25914
25915 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25916 {
25917 PyThreadState* __tstate = wxPyBeginAllowThreads();
25918 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25919 wxPyEndAllowThreads(__tstate);
25920 if (PyErr_Occurred()) SWIG_fail;
25921 }
25922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25923 return resultobj;
25924 fail:
25925 return NULL;
25926 }
25927
25928
25929 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25930 PyObject *resultobj = 0;
25931 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25932 bool result;
25933 void *argp1 = 0 ;
25934 int res1 = 0 ;
25935 PyObject *swig_obj[1] ;
25936
25937 if (!args) SWIG_fail;
25938 swig_obj[0] = args;
25939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25940 if (!SWIG_IsOK(res1)) {
25941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25942 }
25943 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 {
25951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25952 }
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25960 PyObject *resultobj = 0;
25961 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25962 bool arg2 ;
25963 void *argp1 = 0 ;
25964 int res1 = 0 ;
25965 bool val2 ;
25966 int ecode2 = 0 ;
25967 PyObject * obj0 = 0 ;
25968 PyObject * obj1 = 0 ;
25969 char * kwnames[] = {
25970 (char *) "self",(char *) "forward", NULL
25971 };
25972
25973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25975 if (!SWIG_IsOK(res1)) {
25976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25977 }
25978 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25980 if (!SWIG_IsOK(ecode2)) {
25981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25982 }
25983 arg2 = static_cast< bool >(val2);
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 (arg1)->SetDirection(arg2);
25987 wxPyEndAllowThreads(__tstate);
25988 if (PyErr_Occurred()) SWIG_fail;
25989 }
25990 resultobj = SWIG_Py_Void();
25991 return resultobj;
25992 fail:
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 PyObject *resultobj = 0;
25999 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26000 bool result;
26001 void *argp1 = 0 ;
26002 int res1 = 0 ;
26003 PyObject *swig_obj[1] ;
26004
26005 if (!args) SWIG_fail;
26006 swig_obj[0] = args;
26007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26008 if (!SWIG_IsOK(res1)) {
26009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26010 }
26011 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 {
26019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26020 }
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj = 0;
26029 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26030 bool arg2 ;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 bool val2 ;
26034 int ecode2 = 0 ;
26035 PyObject * obj0 = 0 ;
26036 PyObject * obj1 = 0 ;
26037 char * kwnames[] = {
26038 (char *) "self",(char *) "ischange", NULL
26039 };
26040
26041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26043 if (!SWIG_IsOK(res1)) {
26044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26045 }
26046 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26047 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26048 if (!SWIG_IsOK(ecode2)) {
26049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26050 }
26051 arg2 = static_cast< bool >(val2);
26052 {
26053 PyThreadState* __tstate = wxPyBeginAllowThreads();
26054 (arg1)->SetWindowChange(arg2);
26055 wxPyEndAllowThreads(__tstate);
26056 if (PyErr_Occurred()) SWIG_fail;
26057 }
26058 resultobj = SWIG_Py_Void();
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26066 PyObject *resultobj = 0;
26067 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26068 bool result;
26069 void *argp1 = 0 ;
26070 int res1 = 0 ;
26071 PyObject *swig_obj[1] ;
26072
26073 if (!args) SWIG_fail;
26074 swig_obj[0] = args;
26075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26076 if (!SWIG_IsOK(res1)) {
26077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26078 }
26079 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 {
26087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26088 }
26089 return resultobj;
26090 fail:
26091 return NULL;
26092 }
26093
26094
26095 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26096 PyObject *resultobj = 0;
26097 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26098 bool arg2 ;
26099 void *argp1 = 0 ;
26100 int res1 = 0 ;
26101 bool val2 ;
26102 int ecode2 = 0 ;
26103 PyObject * obj0 = 0 ;
26104 PyObject * obj1 = 0 ;
26105 char * kwnames[] = {
26106 (char *) "self",(char *) "bIs", NULL
26107 };
26108
26109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26111 if (!SWIG_IsOK(res1)) {
26112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26113 }
26114 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26115 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26116 if (!SWIG_IsOK(ecode2)) {
26117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26118 }
26119 arg2 = static_cast< bool >(val2);
26120 {
26121 PyThreadState* __tstate = wxPyBeginAllowThreads();
26122 (arg1)->SetFromTab(arg2);
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 resultobj = SWIG_Py_Void();
26127 return resultobj;
26128 fail:
26129 return NULL;
26130 }
26131
26132
26133 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26134 PyObject *resultobj = 0;
26135 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26136 long arg2 ;
26137 void *argp1 = 0 ;
26138 int res1 = 0 ;
26139 long val2 ;
26140 int ecode2 = 0 ;
26141 PyObject * obj0 = 0 ;
26142 PyObject * obj1 = 0 ;
26143 char * kwnames[] = {
26144 (char *) "self",(char *) "flags", NULL
26145 };
26146
26147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26149 if (!SWIG_IsOK(res1)) {
26150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26151 }
26152 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26153 ecode2 = SWIG_AsVal_long(obj1, &val2);
26154 if (!SWIG_IsOK(ecode2)) {
26155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26156 }
26157 arg2 = static_cast< long >(val2);
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 (arg1)->SetFlags(arg2);
26161 wxPyEndAllowThreads(__tstate);
26162 if (PyErr_Occurred()) SWIG_fail;
26163 }
26164 resultobj = SWIG_Py_Void();
26165 return resultobj;
26166 fail:
26167 return NULL;
26168 }
26169
26170
26171 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26172 PyObject *resultobj = 0;
26173 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26174 wxWindow *result = 0 ;
26175 void *argp1 = 0 ;
26176 int res1 = 0 ;
26177 PyObject *swig_obj[1] ;
26178
26179 if (!args) SWIG_fail;
26180 swig_obj[0] = args;
26181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26182 if (!SWIG_IsOK(res1)) {
26183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26184 }
26185 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26186 {
26187 PyThreadState* __tstate = wxPyBeginAllowThreads();
26188 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26189 wxPyEndAllowThreads(__tstate);
26190 if (PyErr_Occurred()) SWIG_fail;
26191 }
26192 {
26193 resultobj = wxPyMake_wxObject(result, (bool)0);
26194 }
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26202 PyObject *resultobj = 0;
26203 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26204 wxWindow *arg2 = (wxWindow *) 0 ;
26205 void *argp1 = 0 ;
26206 int res1 = 0 ;
26207 void *argp2 = 0 ;
26208 int res2 = 0 ;
26209 PyObject * obj0 = 0 ;
26210 PyObject * obj1 = 0 ;
26211 char * kwnames[] = {
26212 (char *) "self",(char *) "win", NULL
26213 };
26214
26215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26217 if (!SWIG_IsOK(res1)) {
26218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26219 }
26220 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26222 if (!SWIG_IsOK(res2)) {
26223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26224 }
26225 arg2 = reinterpret_cast< wxWindow * >(argp2);
26226 {
26227 PyThreadState* __tstate = wxPyBeginAllowThreads();
26228 (arg1)->SetCurrentFocus(arg2);
26229 wxPyEndAllowThreads(__tstate);
26230 if (PyErr_Occurred()) SWIG_fail;
26231 }
26232 resultobj = SWIG_Py_Void();
26233 return resultobj;
26234 fail:
26235 return NULL;
26236 }
26237
26238
26239 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26240 PyObject *obj;
26241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26242 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26243 return SWIG_Py_Void();
26244 }
26245
26246 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26247 return SWIG_Python_InitShadowInstance(args);
26248 }
26249
26250 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26251 PyObject *resultobj = 0;
26252 wxWindow *arg1 = (wxWindow *) NULL ;
26253 wxWindowCreateEvent *result = 0 ;
26254 void *argp1 = 0 ;
26255 int res1 = 0 ;
26256 PyObject * obj0 = 0 ;
26257 char * kwnames[] = {
26258 (char *) "win", NULL
26259 };
26260
26261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26262 if (obj0) {
26263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26264 if (!SWIG_IsOK(res1)) {
26265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26266 }
26267 arg1 = reinterpret_cast< wxWindow * >(argp1);
26268 }
26269 {
26270 PyThreadState* __tstate = wxPyBeginAllowThreads();
26271 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26272 wxPyEndAllowThreads(__tstate);
26273 if (PyErr_Occurred()) SWIG_fail;
26274 }
26275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26276 return resultobj;
26277 fail:
26278 return NULL;
26279 }
26280
26281
26282 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26283 PyObject *resultobj = 0;
26284 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26285 wxWindow *result = 0 ;
26286 void *argp1 = 0 ;
26287 int res1 = 0 ;
26288 PyObject *swig_obj[1] ;
26289
26290 if (!args) SWIG_fail;
26291 swig_obj[0] = args;
26292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26293 if (!SWIG_IsOK(res1)) {
26294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26295 }
26296 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26297 {
26298 PyThreadState* __tstate = wxPyBeginAllowThreads();
26299 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 {
26304 resultobj = wxPyMake_wxObject(result, (bool)0);
26305 }
26306 return resultobj;
26307 fail:
26308 return NULL;
26309 }
26310
26311
26312 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26313 PyObject *obj;
26314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26315 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26316 return SWIG_Py_Void();
26317 }
26318
26319 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26320 return SWIG_Python_InitShadowInstance(args);
26321 }
26322
26323 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj = 0;
26325 wxWindow *arg1 = (wxWindow *) NULL ;
26326 wxWindowDestroyEvent *result = 0 ;
26327 void *argp1 = 0 ;
26328 int res1 = 0 ;
26329 PyObject * obj0 = 0 ;
26330 char * kwnames[] = {
26331 (char *) "win", NULL
26332 };
26333
26334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26335 if (obj0) {
26336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26337 if (!SWIG_IsOK(res1)) {
26338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26339 }
26340 arg1 = reinterpret_cast< wxWindow * >(argp1);
26341 }
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26345 wxPyEndAllowThreads(__tstate);
26346 if (PyErr_Occurred()) SWIG_fail;
26347 }
26348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26349 return resultobj;
26350 fail:
26351 return NULL;
26352 }
26353
26354
26355 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26356 PyObject *resultobj = 0;
26357 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26358 wxWindow *result = 0 ;
26359 void *argp1 = 0 ;
26360 int res1 = 0 ;
26361 PyObject *swig_obj[1] ;
26362
26363 if (!args) SWIG_fail;
26364 swig_obj[0] = args;
26365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26366 if (!SWIG_IsOK(res1)) {
26367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26368 }
26369 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26370 {
26371 PyThreadState* __tstate = wxPyBeginAllowThreads();
26372 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26373 wxPyEndAllowThreads(__tstate);
26374 if (PyErr_Occurred()) SWIG_fail;
26375 }
26376 {
26377 resultobj = wxPyMake_wxObject(result, (bool)0);
26378 }
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26386 PyObject *obj;
26387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26388 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26389 return SWIG_Py_Void();
26390 }
26391
26392 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26393 return SWIG_Python_InitShadowInstance(args);
26394 }
26395
26396 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26397 PyObject *resultobj = 0;
26398 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26399 int arg2 = (int) 0 ;
26400 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26401 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26402 wxContextMenuEvent *result = 0 ;
26403 int val1 ;
26404 int ecode1 = 0 ;
26405 int val2 ;
26406 int ecode2 = 0 ;
26407 wxPoint temp3 ;
26408 PyObject * obj0 = 0 ;
26409 PyObject * obj1 = 0 ;
26410 PyObject * obj2 = 0 ;
26411 char * kwnames[] = {
26412 (char *) "type",(char *) "winid",(char *) "pt", NULL
26413 };
26414
26415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26416 if (obj0) {
26417 ecode1 = SWIG_AsVal_int(obj0, &val1);
26418 if (!SWIG_IsOK(ecode1)) {
26419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26420 }
26421 arg1 = static_cast< wxEventType >(val1);
26422 }
26423 if (obj1) {
26424 ecode2 = SWIG_AsVal_int(obj1, &val2);
26425 if (!SWIG_IsOK(ecode2)) {
26426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26427 }
26428 arg2 = static_cast< int >(val2);
26429 }
26430 if (obj2) {
26431 {
26432 arg3 = &temp3;
26433 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26434 }
26435 }
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26450 PyObject *resultobj = 0;
26451 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26452 wxPoint *result = 0 ;
26453 void *argp1 = 0 ;
26454 int res1 = 0 ;
26455 PyObject *swig_obj[1] ;
26456
26457 if (!args) SWIG_fail;
26458 swig_obj[0] = args;
26459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26460 if (!SWIG_IsOK(res1)) {
26461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26462 }
26463 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 {
26467 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26468 result = (wxPoint *) &_result_ref;
26469 }
26470 wxPyEndAllowThreads(__tstate);
26471 if (PyErr_Occurred()) SWIG_fail;
26472 }
26473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj = 0;
26482 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26483 wxPoint *arg2 = 0 ;
26484 void *argp1 = 0 ;
26485 int res1 = 0 ;
26486 wxPoint temp2 ;
26487 PyObject * obj0 = 0 ;
26488 PyObject * obj1 = 0 ;
26489 char * kwnames[] = {
26490 (char *) "self",(char *) "pos", NULL
26491 };
26492
26493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26495 if (!SWIG_IsOK(res1)) {
26496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26497 }
26498 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26499 {
26500 arg2 = &temp2;
26501 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26502 }
26503 {
26504 PyThreadState* __tstate = wxPyBeginAllowThreads();
26505 (arg1)->SetPosition((wxPoint const &)*arg2);
26506 wxPyEndAllowThreads(__tstate);
26507 if (PyErr_Occurred()) SWIG_fail;
26508 }
26509 resultobj = SWIG_Py_Void();
26510 return resultobj;
26511 fail:
26512 return NULL;
26513 }
26514
26515
26516 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26517 PyObject *obj;
26518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26519 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26520 return SWIG_Py_Void();
26521 }
26522
26523 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26524 return SWIG_Python_InitShadowInstance(args);
26525 }
26526
26527 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26528 PyObject *resultobj = 0;
26529 wxIdleEvent *result = 0 ;
26530
26531 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = (wxIdleEvent *)new wxIdleEvent();
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj = 0;
26547 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26548 bool arg2 = (bool) true ;
26549 void *argp1 = 0 ;
26550 int res1 = 0 ;
26551 bool val2 ;
26552 int ecode2 = 0 ;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555 char * kwnames[] = {
26556 (char *) "self",(char *) "needMore", NULL
26557 };
26558
26559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26561 if (!SWIG_IsOK(res1)) {
26562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26563 }
26564 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26565 if (obj1) {
26566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26567 if (!SWIG_IsOK(ecode2)) {
26568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26569 }
26570 arg2 = static_cast< bool >(val2);
26571 }
26572 {
26573 PyThreadState* __tstate = wxPyBeginAllowThreads();
26574 (arg1)->RequestMore(arg2);
26575 wxPyEndAllowThreads(__tstate);
26576 if (PyErr_Occurred()) SWIG_fail;
26577 }
26578 resultobj = SWIG_Py_Void();
26579 return resultobj;
26580 fail:
26581 return NULL;
26582 }
26583
26584
26585 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26586 PyObject *resultobj = 0;
26587 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26588 bool result;
26589 void *argp1 = 0 ;
26590 int res1 = 0 ;
26591 PyObject *swig_obj[1] ;
26592
26593 if (!args) SWIG_fail;
26594 swig_obj[0] = args;
26595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26596 if (!SWIG_IsOK(res1)) {
26597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26598 }
26599 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26603 wxPyEndAllowThreads(__tstate);
26604 if (PyErr_Occurred()) SWIG_fail;
26605 }
26606 {
26607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26608 }
26609 return resultobj;
26610 fail:
26611 return NULL;
26612 }
26613
26614
26615 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26616 PyObject *resultobj = 0;
26617 wxIdleMode arg1 ;
26618 int val1 ;
26619 int ecode1 = 0 ;
26620 PyObject * obj0 = 0 ;
26621 char * kwnames[] = {
26622 (char *) "mode", NULL
26623 };
26624
26625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26626 ecode1 = SWIG_AsVal_int(obj0, &val1);
26627 if (!SWIG_IsOK(ecode1)) {
26628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26629 }
26630 arg1 = static_cast< wxIdleMode >(val1);
26631 {
26632 PyThreadState* __tstate = wxPyBeginAllowThreads();
26633 wxIdleEvent::SetMode(arg1);
26634 wxPyEndAllowThreads(__tstate);
26635 if (PyErr_Occurred()) SWIG_fail;
26636 }
26637 resultobj = SWIG_Py_Void();
26638 return resultobj;
26639 fail:
26640 return NULL;
26641 }
26642
26643
26644 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26645 PyObject *resultobj = 0;
26646 wxIdleMode result;
26647
26648 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 result = (wxIdleMode)wxIdleEvent::GetMode();
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 resultobj = SWIG_From_int(static_cast< int >(result));
26656 return resultobj;
26657 fail:
26658 return NULL;
26659 }
26660
26661
26662 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26663 PyObject *resultobj = 0;
26664 wxWindow *arg1 = (wxWindow *) 0 ;
26665 bool result;
26666 void *argp1 = 0 ;
26667 int res1 = 0 ;
26668 PyObject * obj0 = 0 ;
26669 char * kwnames[] = {
26670 (char *) "win", NULL
26671 };
26672
26673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26675 if (!SWIG_IsOK(res1)) {
26676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26677 }
26678 arg1 = reinterpret_cast< wxWindow * >(argp1);
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 result = (bool)wxIdleEvent::CanSend(arg1);
26682 wxPyEndAllowThreads(__tstate);
26683 if (PyErr_Occurred()) SWIG_fail;
26684 }
26685 {
26686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26687 }
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26695 PyObject *obj;
26696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26697 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26698 return SWIG_Py_Void();
26699 }
26700
26701 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 return SWIG_Python_InitShadowInstance(args);
26703 }
26704
26705 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26706 PyObject *resultobj = 0;
26707 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26708 int arg2 = (int) 0 ;
26709 wxClipboardTextEvent *result = 0 ;
26710 int val1 ;
26711 int ecode1 = 0 ;
26712 int val2 ;
26713 int ecode2 = 0 ;
26714 PyObject * obj0 = 0 ;
26715 PyObject * obj1 = 0 ;
26716 char * kwnames[] = {
26717 (char *) "type",(char *) "winid", NULL
26718 };
26719
26720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26721 if (obj0) {
26722 ecode1 = SWIG_AsVal_int(obj0, &val1);
26723 if (!SWIG_IsOK(ecode1)) {
26724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26725 }
26726 arg1 = static_cast< wxEventType >(val1);
26727 }
26728 if (obj1) {
26729 ecode2 = SWIG_AsVal_int(obj1, &val2);
26730 if (!SWIG_IsOK(ecode2)) {
26731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26732 }
26733 arg2 = static_cast< int >(val2);
26734 }
26735 {
26736 PyThreadState* __tstate = wxPyBeginAllowThreads();
26737 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26738 wxPyEndAllowThreads(__tstate);
26739 if (PyErr_Occurred()) SWIG_fail;
26740 }
26741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26742 return resultobj;
26743 fail:
26744 return NULL;
26745 }
26746
26747
26748 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26749 PyObject *obj;
26750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26751 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26752 return SWIG_Py_Void();
26753 }
26754
26755 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26756 return SWIG_Python_InitShadowInstance(args);
26757 }
26758
26759 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26760 PyObject *resultobj = 0;
26761 int arg1 = (int) 0 ;
26762 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26763 wxPyEvent *result = 0 ;
26764 int val1 ;
26765 int ecode1 = 0 ;
26766 int val2 ;
26767 int ecode2 = 0 ;
26768 PyObject * obj0 = 0 ;
26769 PyObject * obj1 = 0 ;
26770 char * kwnames[] = {
26771 (char *) "winid",(char *) "eventType", NULL
26772 };
26773
26774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26775 if (obj0) {
26776 ecode1 = SWIG_AsVal_int(obj0, &val1);
26777 if (!SWIG_IsOK(ecode1)) {
26778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26779 }
26780 arg1 = static_cast< int >(val1);
26781 }
26782 if (obj1) {
26783 ecode2 = SWIG_AsVal_int(obj1, &val2);
26784 if (!SWIG_IsOK(ecode2)) {
26785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26786 }
26787 arg2 = static_cast< wxEventType >(val2);
26788 }
26789 {
26790 PyThreadState* __tstate = wxPyBeginAllowThreads();
26791 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26792 wxPyEndAllowThreads(__tstate);
26793 if (PyErr_Occurred()) SWIG_fail;
26794 }
26795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26796 return resultobj;
26797 fail:
26798 return NULL;
26799 }
26800
26801
26802 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26803 PyObject *resultobj = 0;
26804 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26805 void *argp1 = 0 ;
26806 int res1 = 0 ;
26807 PyObject *swig_obj[1] ;
26808
26809 if (!args) SWIG_fail;
26810 swig_obj[0] = args;
26811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26812 if (!SWIG_IsOK(res1)) {
26813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26814 }
26815 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26816 {
26817 PyThreadState* __tstate = wxPyBeginAllowThreads();
26818 delete arg1;
26819
26820 wxPyEndAllowThreads(__tstate);
26821 if (PyErr_Occurred()) SWIG_fail;
26822 }
26823 resultobj = SWIG_Py_Void();
26824 return resultobj;
26825 fail:
26826 return NULL;
26827 }
26828
26829
26830 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26831 PyObject *resultobj = 0;
26832 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26833 PyObject *arg2 = (PyObject *) 0 ;
26834 void *argp1 = 0 ;
26835 int res1 = 0 ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 char * kwnames[] = {
26839 (char *) "self",(char *) "self", NULL
26840 };
26841
26842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26844 if (!SWIG_IsOK(res1)) {
26845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26846 }
26847 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26848 arg2 = obj1;
26849 {
26850 PyThreadState* __tstate = wxPyBeginAllowThreads();
26851 (arg1)->SetSelf(arg2);
26852 wxPyEndAllowThreads(__tstate);
26853 if (PyErr_Occurred()) SWIG_fail;
26854 }
26855 resultobj = SWIG_Py_Void();
26856 return resultobj;
26857 fail:
26858 return NULL;
26859 }
26860
26861
26862 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26863 PyObject *resultobj = 0;
26864 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26865 PyObject *result = 0 ;
26866 void *argp1 = 0 ;
26867 int res1 = 0 ;
26868 PyObject *swig_obj[1] ;
26869
26870 if (!args) SWIG_fail;
26871 swig_obj[0] = args;
26872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26873 if (!SWIG_IsOK(res1)) {
26874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26875 }
26876 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 result = (PyObject *)(arg1)->GetSelf();
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 resultobj = result;
26884 return resultobj;
26885 fail:
26886 return NULL;
26887 }
26888
26889
26890 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26891 PyObject *obj;
26892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26893 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26894 return SWIG_Py_Void();
26895 }
26896
26897 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26898 return SWIG_Python_InitShadowInstance(args);
26899 }
26900
26901 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26902 PyObject *resultobj = 0;
26903 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26904 int arg2 = (int) 0 ;
26905 wxPyCommandEvent *result = 0 ;
26906 int val1 ;
26907 int ecode1 = 0 ;
26908 int val2 ;
26909 int ecode2 = 0 ;
26910 PyObject * obj0 = 0 ;
26911 PyObject * obj1 = 0 ;
26912 char * kwnames[] = {
26913 (char *) "eventType",(char *) "id", NULL
26914 };
26915
26916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26917 if (obj0) {
26918 ecode1 = SWIG_AsVal_int(obj0, &val1);
26919 if (!SWIG_IsOK(ecode1)) {
26920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26921 }
26922 arg1 = static_cast< wxEventType >(val1);
26923 }
26924 if (obj1) {
26925 ecode2 = SWIG_AsVal_int(obj1, &val2);
26926 if (!SWIG_IsOK(ecode2)) {
26927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26928 }
26929 arg2 = static_cast< int >(val2);
26930 }
26931 {
26932 PyThreadState* __tstate = wxPyBeginAllowThreads();
26933 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26934 wxPyEndAllowThreads(__tstate);
26935 if (PyErr_Occurred()) SWIG_fail;
26936 }
26937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26945 PyObject *resultobj = 0;
26946 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26947 void *argp1 = 0 ;
26948 int res1 = 0 ;
26949 PyObject *swig_obj[1] ;
26950
26951 if (!args) SWIG_fail;
26952 swig_obj[0] = args;
26953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26954 if (!SWIG_IsOK(res1)) {
26955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26956 }
26957 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 delete arg1;
26961
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 resultobj = SWIG_Py_Void();
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26973 PyObject *resultobj = 0;
26974 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26975 PyObject *arg2 = (PyObject *) 0 ;
26976 void *argp1 = 0 ;
26977 int res1 = 0 ;
26978 PyObject * obj0 = 0 ;
26979 PyObject * obj1 = 0 ;
26980 char * kwnames[] = {
26981 (char *) "self",(char *) "self", NULL
26982 };
26983
26984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26986 if (!SWIG_IsOK(res1)) {
26987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26988 }
26989 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26990 arg2 = obj1;
26991 {
26992 PyThreadState* __tstate = wxPyBeginAllowThreads();
26993 (arg1)->SetSelf(arg2);
26994 wxPyEndAllowThreads(__tstate);
26995 if (PyErr_Occurred()) SWIG_fail;
26996 }
26997 resultobj = SWIG_Py_Void();
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27005 PyObject *resultobj = 0;
27006 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27007 PyObject *result = 0 ;
27008 void *argp1 = 0 ;
27009 int res1 = 0 ;
27010 PyObject *swig_obj[1] ;
27011
27012 if (!args) SWIG_fail;
27013 swig_obj[0] = args;
27014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27015 if (!SWIG_IsOK(res1)) {
27016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27017 }
27018 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27019 {
27020 PyThreadState* __tstate = wxPyBeginAllowThreads();
27021 result = (PyObject *)(arg1)->GetSelf();
27022 wxPyEndAllowThreads(__tstate);
27023 if (PyErr_Occurred()) SWIG_fail;
27024 }
27025 resultobj = result;
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27033 PyObject *obj;
27034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27035 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27036 return SWIG_Py_Void();
27037 }
27038
27039 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27040 return SWIG_Python_InitShadowInstance(args);
27041 }
27042
27043 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27044 PyObject *resultobj = 0;
27045 wxWindow *arg1 = (wxWindow *) 0 ;
27046 wxDateTime *arg2 = 0 ;
27047 wxEventType arg3 ;
27048 wxDateEvent *result = 0 ;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 void *argp2 = 0 ;
27052 int res2 = 0 ;
27053 int val3 ;
27054 int ecode3 = 0 ;
27055 PyObject * obj0 = 0 ;
27056 PyObject * obj1 = 0 ;
27057 PyObject * obj2 = 0 ;
27058 char * kwnames[] = {
27059 (char *) "win",(char *) "dt",(char *) "type", NULL
27060 };
27061
27062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27064 if (!SWIG_IsOK(res1)) {
27065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27066 }
27067 arg1 = reinterpret_cast< wxWindow * >(argp1);
27068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27069 if (!SWIG_IsOK(res2)) {
27070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27071 }
27072 if (!argp2) {
27073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27074 }
27075 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27076 ecode3 = SWIG_AsVal_int(obj2, &val3);
27077 if (!SWIG_IsOK(ecode3)) {
27078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27079 }
27080 arg3 = static_cast< wxEventType >(val3);
27081 {
27082 PyThreadState* __tstate = wxPyBeginAllowThreads();
27083 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27084 wxPyEndAllowThreads(__tstate);
27085 if (PyErr_Occurred()) SWIG_fail;
27086 }
27087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27088 return resultobj;
27089 fail:
27090 return NULL;
27091 }
27092
27093
27094 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27095 PyObject *resultobj = 0;
27096 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27097 wxDateTime *result = 0 ;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 PyObject *swig_obj[1] ;
27101
27102 if (!args) SWIG_fail;
27103 swig_obj[0] = args;
27104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27107 }
27108 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27109 {
27110 PyThreadState* __tstate = wxPyBeginAllowThreads();
27111 {
27112 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27113 result = (wxDateTime *) &_result_ref;
27114 }
27115 wxPyEndAllowThreads(__tstate);
27116 if (PyErr_Occurred()) SWIG_fail;
27117 }
27118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27119 return resultobj;
27120 fail:
27121 return NULL;
27122 }
27123
27124
27125 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27126 PyObject *resultobj = 0;
27127 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27128 wxDateTime *arg2 = 0 ;
27129 void *argp1 = 0 ;
27130 int res1 = 0 ;
27131 void *argp2 = 0 ;
27132 int res2 = 0 ;
27133 PyObject * obj0 = 0 ;
27134 PyObject * obj1 = 0 ;
27135 char * kwnames[] = {
27136 (char *) "self",(char *) "date", NULL
27137 };
27138
27139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27141 if (!SWIG_IsOK(res1)) {
27142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27143 }
27144 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27145 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27146 if (!SWIG_IsOK(res2)) {
27147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27148 }
27149 if (!argp2) {
27150 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27151 }
27152 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27153 {
27154 PyThreadState* __tstate = wxPyBeginAllowThreads();
27155 (arg1)->SetDate((wxDateTime const &)*arg2);
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 resultobj = SWIG_Py_Void();
27160 return resultobj;
27161 fail:
27162 return NULL;
27163 }
27164
27165
27166 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27167 PyObject *obj;
27168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27169 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27170 return SWIG_Py_Void();
27171 }
27172
27173 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27174 return SWIG_Python_InitShadowInstance(args);
27175 }
27176
27177 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27178 PyObject *resultobj = 0;
27179 wxPyApp *result = 0 ;
27180
27181 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27182 {
27183 PyThreadState* __tstate = wxPyBeginAllowThreads();
27184 result = (wxPyApp *)new_wxPyApp();
27185 wxPyEndAllowThreads(__tstate);
27186 if (PyErr_Occurred()) SWIG_fail;
27187 }
27188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27189 return resultobj;
27190 fail:
27191 return NULL;
27192 }
27193
27194
27195 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27196 PyObject *resultobj = 0;
27197 wxPyApp *arg1 = (wxPyApp *) 0 ;
27198 void *argp1 = 0 ;
27199 int res1 = 0 ;
27200 PyObject *swig_obj[1] ;
27201
27202 if (!args) SWIG_fail;
27203 swig_obj[0] = args;
27204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27205 if (!SWIG_IsOK(res1)) {
27206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27207 }
27208 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27209 {
27210 PyThreadState* __tstate = wxPyBeginAllowThreads();
27211 delete arg1;
27212
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 resultobj = SWIG_Py_Void();
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27224 PyObject *resultobj = 0;
27225 wxPyApp *arg1 = (wxPyApp *) 0 ;
27226 PyObject *arg2 = (PyObject *) 0 ;
27227 PyObject *arg3 = (PyObject *) 0 ;
27228 bool arg4 ;
27229 void *argp1 = 0 ;
27230 int res1 = 0 ;
27231 bool val4 ;
27232 int ecode4 = 0 ;
27233 PyObject * obj0 = 0 ;
27234 PyObject * obj1 = 0 ;
27235 PyObject * obj2 = 0 ;
27236 PyObject * obj3 = 0 ;
27237 char * kwnames[] = {
27238 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27239 };
27240
27241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27243 if (!SWIG_IsOK(res1)) {
27244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27245 }
27246 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27247 arg2 = obj1;
27248 arg3 = obj2;
27249 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27250 if (!SWIG_IsOK(ecode4)) {
27251 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27252 }
27253 arg4 = static_cast< bool >(val4);
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 resultobj = SWIG_Py_Void();
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27268 PyObject *resultobj = 0;
27269 wxPyApp *arg1 = (wxPyApp *) 0 ;
27270 wxString result;
27271 void *argp1 = 0 ;
27272 int res1 = 0 ;
27273 PyObject *swig_obj[1] ;
27274
27275 if (!args) SWIG_fail;
27276 swig_obj[0] = args;
27277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27278 if (!SWIG_IsOK(res1)) {
27279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27280 }
27281 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 result = ((wxPyApp const *)arg1)->GetAppName();
27285 wxPyEndAllowThreads(__tstate);
27286 if (PyErr_Occurred()) SWIG_fail;
27287 }
27288 {
27289 #if wxUSE_UNICODE
27290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27291 #else
27292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27293 #endif
27294 }
27295 return resultobj;
27296 fail:
27297 return NULL;
27298 }
27299
27300
27301 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27302 PyObject *resultobj = 0;
27303 wxPyApp *arg1 = (wxPyApp *) 0 ;
27304 wxString *arg2 = 0 ;
27305 void *argp1 = 0 ;
27306 int res1 = 0 ;
27307 bool temp2 = false ;
27308 PyObject * obj0 = 0 ;
27309 PyObject * obj1 = 0 ;
27310 char * kwnames[] = {
27311 (char *) "self",(char *) "name", NULL
27312 };
27313
27314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27316 if (!SWIG_IsOK(res1)) {
27317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27318 }
27319 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27320 {
27321 arg2 = wxString_in_helper(obj1);
27322 if (arg2 == NULL) SWIG_fail;
27323 temp2 = true;
27324 }
27325 {
27326 PyThreadState* __tstate = wxPyBeginAllowThreads();
27327 (arg1)->SetAppName((wxString const &)*arg2);
27328 wxPyEndAllowThreads(__tstate);
27329 if (PyErr_Occurred()) SWIG_fail;
27330 }
27331 resultobj = SWIG_Py_Void();
27332 {
27333 if (temp2)
27334 delete arg2;
27335 }
27336 return resultobj;
27337 fail:
27338 {
27339 if (temp2)
27340 delete arg2;
27341 }
27342 return NULL;
27343 }
27344
27345
27346 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27347 PyObject *resultobj = 0;
27348 wxPyApp *arg1 = (wxPyApp *) 0 ;
27349 wxString result;
27350 void *argp1 = 0 ;
27351 int res1 = 0 ;
27352 PyObject *swig_obj[1] ;
27353
27354 if (!args) SWIG_fail;
27355 swig_obj[0] = args;
27356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27357 if (!SWIG_IsOK(res1)) {
27358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27359 }
27360 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27361 {
27362 PyThreadState* __tstate = wxPyBeginAllowThreads();
27363 result = ((wxPyApp const *)arg1)->GetClassName();
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 {
27368 #if wxUSE_UNICODE
27369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27370 #else
27371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27372 #endif
27373 }
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27381 PyObject *resultobj = 0;
27382 wxPyApp *arg1 = (wxPyApp *) 0 ;
27383 wxString *arg2 = 0 ;
27384 void *argp1 = 0 ;
27385 int res1 = 0 ;
27386 bool temp2 = false ;
27387 PyObject * obj0 = 0 ;
27388 PyObject * obj1 = 0 ;
27389 char * kwnames[] = {
27390 (char *) "self",(char *) "name", NULL
27391 };
27392
27393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27395 if (!SWIG_IsOK(res1)) {
27396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27397 }
27398 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27399 {
27400 arg2 = wxString_in_helper(obj1);
27401 if (arg2 == NULL) SWIG_fail;
27402 temp2 = true;
27403 }
27404 {
27405 PyThreadState* __tstate = wxPyBeginAllowThreads();
27406 (arg1)->SetClassName((wxString const &)*arg2);
27407 wxPyEndAllowThreads(__tstate);
27408 if (PyErr_Occurred()) SWIG_fail;
27409 }
27410 resultobj = SWIG_Py_Void();
27411 {
27412 if (temp2)
27413 delete arg2;
27414 }
27415 return resultobj;
27416 fail:
27417 {
27418 if (temp2)
27419 delete arg2;
27420 }
27421 return NULL;
27422 }
27423
27424
27425 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27426 PyObject *resultobj = 0;
27427 wxPyApp *arg1 = (wxPyApp *) 0 ;
27428 wxString *result = 0 ;
27429 void *argp1 = 0 ;
27430 int res1 = 0 ;
27431 PyObject *swig_obj[1] ;
27432
27433 if (!args) SWIG_fail;
27434 swig_obj[0] = args;
27435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27436 if (!SWIG_IsOK(res1)) {
27437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27438 }
27439 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27440 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 {
27443 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27444 result = (wxString *) &_result_ref;
27445 }
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 {
27450 #if wxUSE_UNICODE
27451 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27452 #else
27453 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27454 #endif
27455 }
27456 return resultobj;
27457 fail:
27458 return NULL;
27459 }
27460
27461
27462 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27463 PyObject *resultobj = 0;
27464 wxPyApp *arg1 = (wxPyApp *) 0 ;
27465 wxString *arg2 = 0 ;
27466 void *argp1 = 0 ;
27467 int res1 = 0 ;
27468 bool temp2 = false ;
27469 PyObject * obj0 = 0 ;
27470 PyObject * obj1 = 0 ;
27471 char * kwnames[] = {
27472 (char *) "self",(char *) "name", NULL
27473 };
27474
27475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27477 if (!SWIG_IsOK(res1)) {
27478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27479 }
27480 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27481 {
27482 arg2 = wxString_in_helper(obj1);
27483 if (arg2 == NULL) SWIG_fail;
27484 temp2 = true;
27485 }
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 (arg1)->SetVendorName((wxString const &)*arg2);
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 resultobj = SWIG_Py_Void();
27493 {
27494 if (temp2)
27495 delete arg2;
27496 }
27497 return resultobj;
27498 fail:
27499 {
27500 if (temp2)
27501 delete arg2;
27502 }
27503 return NULL;
27504 }
27505
27506
27507 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27508 PyObject *resultobj = 0;
27509 wxPyApp *arg1 = (wxPyApp *) 0 ;
27510 wxAppTraits *result = 0 ;
27511 void *argp1 = 0 ;
27512 int res1 = 0 ;
27513 PyObject *swig_obj[1] ;
27514
27515 if (!args) SWIG_fail;
27516 swig_obj[0] = args;
27517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27518 if (!SWIG_IsOK(res1)) {
27519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27520 }
27521 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 result = (wxAppTraits *)(arg1)->GetTraits();
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27529 return resultobj;
27530 fail:
27531 return NULL;
27532 }
27533
27534
27535 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27536 PyObject *resultobj = 0;
27537 wxPyApp *arg1 = (wxPyApp *) 0 ;
27538 void *argp1 = 0 ;
27539 int res1 = 0 ;
27540 PyObject *swig_obj[1] ;
27541
27542 if (!args) SWIG_fail;
27543 swig_obj[0] = args;
27544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27545 if (!SWIG_IsOK(res1)) {
27546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27547 }
27548 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27549 {
27550 PyThreadState* __tstate = wxPyBeginAllowThreads();
27551 (arg1)->ProcessPendingEvents();
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 resultobj = SWIG_Py_Void();
27556 return resultobj;
27557 fail:
27558 return NULL;
27559 }
27560
27561
27562 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27563 PyObject *resultobj = 0;
27564 wxPyApp *arg1 = (wxPyApp *) 0 ;
27565 bool arg2 = (bool) false ;
27566 bool result;
27567 void *argp1 = 0 ;
27568 int res1 = 0 ;
27569 bool val2 ;
27570 int ecode2 = 0 ;
27571 PyObject * obj0 = 0 ;
27572 PyObject * obj1 = 0 ;
27573 char * kwnames[] = {
27574 (char *) "self",(char *) "onlyIfNeeded", NULL
27575 };
27576
27577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27579 if (!SWIG_IsOK(res1)) {
27580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27581 }
27582 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27583 if (obj1) {
27584 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27585 if (!SWIG_IsOK(ecode2)) {
27586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27587 }
27588 arg2 = static_cast< bool >(val2);
27589 }
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 result = (bool)(arg1)->Yield(arg2);
27593 wxPyEndAllowThreads(__tstate);
27594 if (PyErr_Occurred()) SWIG_fail;
27595 }
27596 {
27597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27598 }
27599 return resultobj;
27600 fail:
27601 return NULL;
27602 }
27603
27604
27605 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27606 PyObject *resultobj = 0;
27607 wxPyApp *arg1 = (wxPyApp *) 0 ;
27608 void *argp1 = 0 ;
27609 int res1 = 0 ;
27610 PyObject *swig_obj[1] ;
27611
27612 if (!args) SWIG_fail;
27613 swig_obj[0] = args;
27614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27615 if (!SWIG_IsOK(res1)) {
27616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27617 }
27618 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27619 {
27620 PyThreadState* __tstate = wxPyBeginAllowThreads();
27621 (arg1)->WakeUpIdle();
27622 wxPyEndAllowThreads(__tstate);
27623 if (PyErr_Occurred()) SWIG_fail;
27624 }
27625 resultobj = SWIG_Py_Void();
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27633 PyObject *resultobj = 0;
27634 bool result;
27635
27636 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 result = (bool)wxPyApp::IsMainLoopRunning();
27640 wxPyEndAllowThreads(__tstate);
27641 if (PyErr_Occurred()) SWIG_fail;
27642 }
27643 {
27644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27645 }
27646 return resultobj;
27647 fail:
27648 return NULL;
27649 }
27650
27651
27652 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27653 PyObject *resultobj = 0;
27654 wxPyApp *arg1 = (wxPyApp *) 0 ;
27655 int result;
27656 void *argp1 = 0 ;
27657 int res1 = 0 ;
27658 PyObject *swig_obj[1] ;
27659
27660 if (!args) SWIG_fail;
27661 swig_obj[0] = args;
27662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27663 if (!SWIG_IsOK(res1)) {
27664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27665 }
27666 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = (int)(arg1)->MainLoop();
27670 wxPyEndAllowThreads(__tstate);
27671 if (PyErr_Occurred()) SWIG_fail;
27672 }
27673 resultobj = SWIG_From_int(static_cast< int >(result));
27674 return resultobj;
27675 fail:
27676 return NULL;
27677 }
27678
27679
27680 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27681 PyObject *resultobj = 0;
27682 wxPyApp *arg1 = (wxPyApp *) 0 ;
27683 void *argp1 = 0 ;
27684 int res1 = 0 ;
27685 PyObject *swig_obj[1] ;
27686
27687 if (!args) SWIG_fail;
27688 swig_obj[0] = args;
27689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27690 if (!SWIG_IsOK(res1)) {
27691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27692 }
27693 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27694 {
27695 PyThreadState* __tstate = wxPyBeginAllowThreads();
27696 (arg1)->Exit();
27697 wxPyEndAllowThreads(__tstate);
27698 if (PyErr_Occurred()) SWIG_fail;
27699 }
27700 resultobj = SWIG_Py_Void();
27701 return resultobj;
27702 fail:
27703 return NULL;
27704 }
27705
27706
27707 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27708 PyObject *resultobj = 0;
27709 wxPyApp *arg1 = (wxPyApp *) 0 ;
27710 void *argp1 = 0 ;
27711 int res1 = 0 ;
27712 PyObject *swig_obj[1] ;
27713
27714 if (!args) SWIG_fail;
27715 swig_obj[0] = args;
27716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27717 if (!SWIG_IsOK(res1)) {
27718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27719 }
27720 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27721 {
27722 PyThreadState* __tstate = wxPyBeginAllowThreads();
27723 (arg1)->ExitMainLoop();
27724 wxPyEndAllowThreads(__tstate);
27725 if (PyErr_Occurred()) SWIG_fail;
27726 }
27727 resultobj = SWIG_Py_Void();
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27735 PyObject *resultobj = 0;
27736 wxPyApp *arg1 = (wxPyApp *) 0 ;
27737 bool result;
27738 void *argp1 = 0 ;
27739 int res1 = 0 ;
27740 PyObject *swig_obj[1] ;
27741
27742 if (!args) SWIG_fail;
27743 swig_obj[0] = args;
27744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27745 if (!SWIG_IsOK(res1)) {
27746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27747 }
27748 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27749 {
27750 PyThreadState* __tstate = wxPyBeginAllowThreads();
27751 result = (bool)(arg1)->Pending();
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 {
27756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27757 }
27758 return resultobj;
27759 fail:
27760 return NULL;
27761 }
27762
27763
27764 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27765 PyObject *resultobj = 0;
27766 wxPyApp *arg1 = (wxPyApp *) 0 ;
27767 bool result;
27768 void *argp1 = 0 ;
27769 int res1 = 0 ;
27770 PyObject *swig_obj[1] ;
27771
27772 if (!args) SWIG_fail;
27773 swig_obj[0] = args;
27774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27775 if (!SWIG_IsOK(res1)) {
27776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27777 }
27778 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (bool)(arg1)->Dispatch();
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 {
27786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27787 }
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27795 PyObject *resultobj = 0;
27796 wxPyApp *arg1 = (wxPyApp *) 0 ;
27797 bool result;
27798 void *argp1 = 0 ;
27799 int res1 = 0 ;
27800 PyObject *swig_obj[1] ;
27801
27802 if (!args) SWIG_fail;
27803 swig_obj[0] = args;
27804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27805 if (!SWIG_IsOK(res1)) {
27806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27807 }
27808 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27809 {
27810 PyThreadState* __tstate = wxPyBeginAllowThreads();
27811 result = (bool)(arg1)->ProcessIdle();
27812 wxPyEndAllowThreads(__tstate);
27813 if (PyErr_Occurred()) SWIG_fail;
27814 }
27815 {
27816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27817 }
27818 return resultobj;
27819 fail:
27820 return NULL;
27821 }
27822
27823
27824 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27825 PyObject *resultobj = 0;
27826 wxPyApp *arg1 = (wxPyApp *) 0 ;
27827 wxWindow *arg2 = (wxWindow *) 0 ;
27828 wxIdleEvent *arg3 = 0 ;
27829 bool result;
27830 void *argp1 = 0 ;
27831 int res1 = 0 ;
27832 void *argp2 = 0 ;
27833 int res2 = 0 ;
27834 void *argp3 = 0 ;
27835 int res3 = 0 ;
27836 PyObject * obj0 = 0 ;
27837 PyObject * obj1 = 0 ;
27838 PyObject * obj2 = 0 ;
27839 char * kwnames[] = {
27840 (char *) "self",(char *) "win",(char *) "event", NULL
27841 };
27842
27843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27845 if (!SWIG_IsOK(res1)) {
27846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27847 }
27848 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27849 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27850 if (!SWIG_IsOK(res2)) {
27851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27852 }
27853 arg2 = reinterpret_cast< wxWindow * >(argp2);
27854 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27855 if (!SWIG_IsOK(res3)) {
27856 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27857 }
27858 if (!argp3) {
27859 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27860 }
27861 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 {
27869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27870 }
27871 return resultobj;
27872 fail:
27873 return NULL;
27874 }
27875
27876
27877 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27878 PyObject *resultobj = 0;
27879 wxPyApp *arg1 = (wxPyApp *) 0 ;
27880 bool result;
27881 void *argp1 = 0 ;
27882 int res1 = 0 ;
27883 PyObject *swig_obj[1] ;
27884
27885 if (!args) SWIG_fail;
27886 swig_obj[0] = args;
27887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27888 if (!SWIG_IsOK(res1)) {
27889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27890 }
27891 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27892 {
27893 PyThreadState* __tstate = wxPyBeginAllowThreads();
27894 result = (bool)((wxPyApp const *)arg1)->IsActive();
27895 wxPyEndAllowThreads(__tstate);
27896 if (PyErr_Occurred()) SWIG_fail;
27897 }
27898 {
27899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27900 }
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj = 0;
27909 wxPyApp *arg1 = (wxPyApp *) 0 ;
27910 wxWindow *arg2 = (wxWindow *) 0 ;
27911 void *argp1 = 0 ;
27912 int res1 = 0 ;
27913 void *argp2 = 0 ;
27914 int res2 = 0 ;
27915 PyObject * obj0 = 0 ;
27916 PyObject * obj1 = 0 ;
27917 char * kwnames[] = {
27918 (char *) "self",(char *) "win", NULL
27919 };
27920
27921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27923 if (!SWIG_IsOK(res1)) {
27924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27925 }
27926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27928 if (!SWIG_IsOK(res2)) {
27929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27930 }
27931 arg2 = reinterpret_cast< wxWindow * >(argp2);
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 (arg1)->SetTopWindow(arg2);
27935 wxPyEndAllowThreads(__tstate);
27936 if (PyErr_Occurred()) SWIG_fail;
27937 }
27938 resultobj = SWIG_Py_Void();
27939 return resultobj;
27940 fail:
27941 return NULL;
27942 }
27943
27944
27945 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27946 PyObject *resultobj = 0;
27947 wxPyApp *arg1 = (wxPyApp *) 0 ;
27948 wxWindow *result = 0 ;
27949 void *argp1 = 0 ;
27950 int res1 = 0 ;
27951 PyObject *swig_obj[1] ;
27952
27953 if (!args) SWIG_fail;
27954 swig_obj[0] = args;
27955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27956 if (!SWIG_IsOK(res1)) {
27957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27958 }
27959 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 {
27967 resultobj = wxPyMake_wxObject(result, (bool)0);
27968 }
27969 return resultobj;
27970 fail:
27971 return NULL;
27972 }
27973
27974
27975 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27976 PyObject *resultobj = 0;
27977 wxPyApp *arg1 = (wxPyApp *) 0 ;
27978 bool arg2 ;
27979 void *argp1 = 0 ;
27980 int res1 = 0 ;
27981 bool val2 ;
27982 int ecode2 = 0 ;
27983 PyObject * obj0 = 0 ;
27984 PyObject * obj1 = 0 ;
27985 char * kwnames[] = {
27986 (char *) "self",(char *) "flag", NULL
27987 };
27988
27989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27991 if (!SWIG_IsOK(res1)) {
27992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27993 }
27994 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27995 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27996 if (!SWIG_IsOK(ecode2)) {
27997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27998 }
27999 arg2 = static_cast< bool >(val2);
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 (arg1)->SetExitOnFrameDelete(arg2);
28003 wxPyEndAllowThreads(__tstate);
28004 if (PyErr_Occurred()) SWIG_fail;
28005 }
28006 resultobj = SWIG_Py_Void();
28007 return resultobj;
28008 fail:
28009 return NULL;
28010 }
28011
28012
28013 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28014 PyObject *resultobj = 0;
28015 wxPyApp *arg1 = (wxPyApp *) 0 ;
28016 bool result;
28017 void *argp1 = 0 ;
28018 int res1 = 0 ;
28019 PyObject *swig_obj[1] ;
28020
28021 if (!args) SWIG_fail;
28022 swig_obj[0] = args;
28023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28024 if (!SWIG_IsOK(res1)) {
28025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28026 }
28027 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28028 {
28029 PyThreadState* __tstate = wxPyBeginAllowThreads();
28030 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28031 wxPyEndAllowThreads(__tstate);
28032 if (PyErr_Occurred()) SWIG_fail;
28033 }
28034 {
28035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28036 }
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj = 0;
28045 wxPyApp *arg1 = (wxPyApp *) 0 ;
28046 bool arg2 ;
28047 void *argp1 = 0 ;
28048 int res1 = 0 ;
28049 bool val2 ;
28050 int ecode2 = 0 ;
28051 PyObject * obj0 = 0 ;
28052 PyObject * obj1 = 0 ;
28053 char * kwnames[] = {
28054 (char *) "self",(char *) "flag", NULL
28055 };
28056
28057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28059 if (!SWIG_IsOK(res1)) {
28060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28061 }
28062 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28063 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28064 if (!SWIG_IsOK(ecode2)) {
28065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28066 }
28067 arg2 = static_cast< bool >(val2);
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 (arg1)->SetUseBestVisual(arg2);
28071 wxPyEndAllowThreads(__tstate);
28072 if (PyErr_Occurred()) SWIG_fail;
28073 }
28074 resultobj = SWIG_Py_Void();
28075 return resultobj;
28076 fail:
28077 return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28082 PyObject *resultobj = 0;
28083 wxPyApp *arg1 = (wxPyApp *) 0 ;
28084 bool result;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 PyObject *swig_obj[1] ;
28088
28089 if (!args) SWIG_fail;
28090 swig_obj[0] = args;
28091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28092 if (!SWIG_IsOK(res1)) {
28093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28094 }
28095 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28096 {
28097 PyThreadState* __tstate = wxPyBeginAllowThreads();
28098 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 {
28103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28104 }
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28112 PyObject *resultobj = 0;
28113 wxPyApp *arg1 = (wxPyApp *) 0 ;
28114 int arg2 ;
28115 void *argp1 = 0 ;
28116 int res1 = 0 ;
28117 int val2 ;
28118 int ecode2 = 0 ;
28119 PyObject * obj0 = 0 ;
28120 PyObject * obj1 = 0 ;
28121 char * kwnames[] = {
28122 (char *) "self",(char *) "mode", NULL
28123 };
28124
28125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28127 if (!SWIG_IsOK(res1)) {
28128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28129 }
28130 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28131 ecode2 = SWIG_AsVal_int(obj1, &val2);
28132 if (!SWIG_IsOK(ecode2)) {
28133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28134 }
28135 arg2 = static_cast< int >(val2);
28136 {
28137 PyThreadState* __tstate = wxPyBeginAllowThreads();
28138 (arg1)->SetPrintMode(arg2);
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 resultobj = SWIG_Py_Void();
28143 return resultobj;
28144 fail:
28145 return NULL;
28146 }
28147
28148
28149 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28150 PyObject *resultobj = 0;
28151 wxPyApp *arg1 = (wxPyApp *) 0 ;
28152 int result;
28153 void *argp1 = 0 ;
28154 int res1 = 0 ;
28155 PyObject *swig_obj[1] ;
28156
28157 if (!args) SWIG_fail;
28158 swig_obj[0] = args;
28159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28160 if (!SWIG_IsOK(res1)) {
28161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28162 }
28163 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_From_int(static_cast< int >(result));
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj = 0;
28179 wxPyApp *arg1 = (wxPyApp *) 0 ;
28180 int arg2 ;
28181 void *argp1 = 0 ;
28182 int res1 = 0 ;
28183 int val2 ;
28184 int ecode2 = 0 ;
28185 PyObject * obj0 = 0 ;
28186 PyObject * obj1 = 0 ;
28187 char * kwnames[] = {
28188 (char *) "self",(char *) "mode", NULL
28189 };
28190
28191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28193 if (!SWIG_IsOK(res1)) {
28194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28195 }
28196 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28197 ecode2 = SWIG_AsVal_int(obj1, &val2);
28198 if (!SWIG_IsOK(ecode2)) {
28199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28200 }
28201 arg2 = static_cast< int >(val2);
28202 {
28203 PyThreadState* __tstate = wxPyBeginAllowThreads();
28204 (arg1)->SetAssertMode(arg2);
28205 wxPyEndAllowThreads(__tstate);
28206 if (PyErr_Occurred()) SWIG_fail;
28207 }
28208 resultobj = SWIG_Py_Void();
28209 return resultobj;
28210 fail:
28211 return NULL;
28212 }
28213
28214
28215 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28216 PyObject *resultobj = 0;
28217 wxPyApp *arg1 = (wxPyApp *) 0 ;
28218 int result;
28219 void *argp1 = 0 ;
28220 int res1 = 0 ;
28221 PyObject *swig_obj[1] ;
28222
28223 if (!args) SWIG_fail;
28224 swig_obj[0] = args;
28225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28226 if (!SWIG_IsOK(res1)) {
28227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28228 }
28229 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 result = (int)(arg1)->GetAssertMode();
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 resultobj = SWIG_From_int(static_cast< int >(result));
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28244 PyObject *resultobj = 0;
28245 bool result;
28246
28247 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28248 {
28249 PyThreadState* __tstate = wxPyBeginAllowThreads();
28250 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28251 wxPyEndAllowThreads(__tstate);
28252 if (PyErr_Occurred()) SWIG_fail;
28253 }
28254 {
28255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28256 }
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28264 PyObject *resultobj = 0;
28265 long result;
28266
28267 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 result = (long)wxPyApp::GetMacAboutMenuItemId();
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 resultobj = SWIG_From_long(static_cast< long >(result));
28275 return resultobj;
28276 fail:
28277 return NULL;
28278 }
28279
28280
28281 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28282 PyObject *resultobj = 0;
28283 long result;
28284
28285 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28286 {
28287 PyThreadState* __tstate = wxPyBeginAllowThreads();
28288 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28289 wxPyEndAllowThreads(__tstate);
28290 if (PyErr_Occurred()) SWIG_fail;
28291 }
28292 resultobj = SWIG_From_long(static_cast< long >(result));
28293 return resultobj;
28294 fail:
28295 return NULL;
28296 }
28297
28298
28299 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28300 PyObject *resultobj = 0;
28301 long result;
28302
28303 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28304 {
28305 PyThreadState* __tstate = wxPyBeginAllowThreads();
28306 result = (long)wxPyApp::GetMacExitMenuItemId();
28307 wxPyEndAllowThreads(__tstate);
28308 if (PyErr_Occurred()) SWIG_fail;
28309 }
28310 resultobj = SWIG_From_long(static_cast< long >(result));
28311 return resultobj;
28312 fail:
28313 return NULL;
28314 }
28315
28316
28317 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28318 PyObject *resultobj = 0;
28319 wxString result;
28320
28321 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = wxPyApp::GetMacHelpMenuTitleName();
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 {
28329 #if wxUSE_UNICODE
28330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28331 #else
28332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28333 #endif
28334 }
28335 return resultobj;
28336 fail:
28337 return NULL;
28338 }
28339
28340
28341 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28342 PyObject *resultobj = 0;
28343 bool arg1 ;
28344 bool val1 ;
28345 int ecode1 = 0 ;
28346 PyObject * obj0 = 0 ;
28347 char * kwnames[] = {
28348 (char *) "val", NULL
28349 };
28350
28351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28352 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28353 if (!SWIG_IsOK(ecode1)) {
28354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28355 }
28356 arg1 = static_cast< bool >(val1);
28357 {
28358 PyThreadState* __tstate = wxPyBeginAllowThreads();
28359 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 resultobj = SWIG_Py_Void();
28364 return resultobj;
28365 fail:
28366 return NULL;
28367 }
28368
28369
28370 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28371 PyObject *resultobj = 0;
28372 long arg1 ;
28373 long val1 ;
28374 int ecode1 = 0 ;
28375 PyObject * obj0 = 0 ;
28376 char * kwnames[] = {
28377 (char *) "val", NULL
28378 };
28379
28380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28381 ecode1 = SWIG_AsVal_long(obj0, &val1);
28382 if (!SWIG_IsOK(ecode1)) {
28383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28384 }
28385 arg1 = static_cast< long >(val1);
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 wxPyApp::SetMacAboutMenuItemId(arg1);
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 resultobj = SWIG_Py_Void();
28393 return resultobj;
28394 fail:
28395 return NULL;
28396 }
28397
28398
28399 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28400 PyObject *resultobj = 0;
28401 long arg1 ;
28402 long val1 ;
28403 int ecode1 = 0 ;
28404 PyObject * obj0 = 0 ;
28405 char * kwnames[] = {
28406 (char *) "val", NULL
28407 };
28408
28409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28410 ecode1 = SWIG_AsVal_long(obj0, &val1);
28411 if (!SWIG_IsOK(ecode1)) {
28412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28413 }
28414 arg1 = static_cast< long >(val1);
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 resultobj = SWIG_Py_Void();
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28429 PyObject *resultobj = 0;
28430 long arg1 ;
28431 long val1 ;
28432 int ecode1 = 0 ;
28433 PyObject * obj0 = 0 ;
28434 char * kwnames[] = {
28435 (char *) "val", NULL
28436 };
28437
28438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28439 ecode1 = SWIG_AsVal_long(obj0, &val1);
28440 if (!SWIG_IsOK(ecode1)) {
28441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28442 }
28443 arg1 = static_cast< long >(val1);
28444 {
28445 PyThreadState* __tstate = wxPyBeginAllowThreads();
28446 wxPyApp::SetMacExitMenuItemId(arg1);
28447 wxPyEndAllowThreads(__tstate);
28448 if (PyErr_Occurred()) SWIG_fail;
28449 }
28450 resultobj = SWIG_Py_Void();
28451 return resultobj;
28452 fail:
28453 return NULL;
28454 }
28455
28456
28457 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28458 PyObject *resultobj = 0;
28459 wxString *arg1 = 0 ;
28460 bool temp1 = false ;
28461 PyObject * obj0 = 0 ;
28462 char * kwnames[] = {
28463 (char *) "val", NULL
28464 };
28465
28466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28467 {
28468 arg1 = wxString_in_helper(obj0);
28469 if (arg1 == NULL) SWIG_fail;
28470 temp1 = true;
28471 }
28472 {
28473 PyThreadState* __tstate = wxPyBeginAllowThreads();
28474 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28475 wxPyEndAllowThreads(__tstate);
28476 if (PyErr_Occurred()) SWIG_fail;
28477 }
28478 resultobj = SWIG_Py_Void();
28479 {
28480 if (temp1)
28481 delete arg1;
28482 }
28483 return resultobj;
28484 fail:
28485 {
28486 if (temp1)
28487 delete arg1;
28488 }
28489 return NULL;
28490 }
28491
28492
28493 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28494 PyObject *resultobj = 0;
28495 wxPyApp *arg1 = (wxPyApp *) 0 ;
28496 void *argp1 = 0 ;
28497 int res1 = 0 ;
28498 PyObject *swig_obj[1] ;
28499
28500 if (!args) SWIG_fail;
28501 swig_obj[0] = args;
28502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28503 if (!SWIG_IsOK(res1)) {
28504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28505 }
28506 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28507 {
28508 PyThreadState* __tstate = wxPyBeginAllowThreads();
28509 (arg1)->_BootstrapApp();
28510 wxPyEndAllowThreads(__tstate);
28511 if (PyErr_Occurred()) SWIG_fail;
28512 }
28513 resultobj = SWIG_Py_Void();
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28521 PyObject *resultobj = 0;
28522 int result;
28523
28524 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 result = (int)wxPyApp_GetComCtl32Version();
28528 wxPyEndAllowThreads(__tstate);
28529 if (PyErr_Occurred()) SWIG_fail;
28530 }
28531 resultobj = SWIG_From_int(static_cast< int >(result));
28532 return resultobj;
28533 fail:
28534 return NULL;
28535 }
28536
28537
28538 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28539 PyObject *resultobj = 0;
28540 bool result;
28541
28542 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (bool)wxPyApp_DisplayAvailable();
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28551 }
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *obj;
28560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28561 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28562 return SWIG_Py_Void();
28563 }
28564
28565 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28566 return SWIG_Python_InitShadowInstance(args);
28567 }
28568
28569 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28570 PyObject *resultobj = 0;
28571
28572 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 wxExit();
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 resultobj = SWIG_Py_Void();
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587 PyObject *resultobj = 0;
28588 bool result;
28589
28590 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28591 {
28592 PyThreadState* __tstate = wxPyBeginAllowThreads();
28593 result = (bool)wxYield();
28594 wxPyEndAllowThreads(__tstate);
28595 if (PyErr_Occurred()) SWIG_fail;
28596 }
28597 {
28598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28599 }
28600 return resultobj;
28601 fail:
28602 return NULL;
28603 }
28604
28605
28606 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28607 PyObject *resultobj = 0;
28608 bool result;
28609
28610 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28611 {
28612 PyThreadState* __tstate = wxPyBeginAllowThreads();
28613 result = (bool)wxYieldIfNeeded();
28614 wxPyEndAllowThreads(__tstate);
28615 if (PyErr_Occurred()) SWIG_fail;
28616 }
28617 {
28618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28619 }
28620 return resultobj;
28621 fail:
28622 return NULL;
28623 }
28624
28625
28626 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28627 PyObject *resultobj = 0;
28628 wxWindow *arg1 = (wxWindow *) NULL ;
28629 bool arg2 = (bool) false ;
28630 bool result;
28631 void *argp1 = 0 ;
28632 int res1 = 0 ;
28633 bool val2 ;
28634 int ecode2 = 0 ;
28635 PyObject * obj0 = 0 ;
28636 PyObject * obj1 = 0 ;
28637 char * kwnames[] = {
28638 (char *) "win",(char *) "onlyIfNeeded", NULL
28639 };
28640
28641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28642 if (obj0) {
28643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28644 if (!SWIG_IsOK(res1)) {
28645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28646 }
28647 arg1 = reinterpret_cast< wxWindow * >(argp1);
28648 }
28649 if (obj1) {
28650 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28651 if (!SWIG_IsOK(ecode2)) {
28652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28653 }
28654 arg2 = static_cast< bool >(val2);
28655 }
28656 {
28657 PyThreadState* __tstate = wxPyBeginAllowThreads();
28658 result = (bool)wxSafeYield(arg1,arg2);
28659 wxPyEndAllowThreads(__tstate);
28660 if (PyErr_Occurred()) SWIG_fail;
28661 }
28662 {
28663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28664 }
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28672 PyObject *resultobj = 0;
28673
28674 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 wxWakeUpIdle();
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 resultobj = SWIG_Py_Void();
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28689 PyObject *resultobj = 0;
28690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28691 wxEvent *arg2 = 0 ;
28692 void *argp1 = 0 ;
28693 int res1 = 0 ;
28694 void *argp2 = 0 ;
28695 int res2 = 0 ;
28696 PyObject * obj0 = 0 ;
28697 PyObject * obj1 = 0 ;
28698 char * kwnames[] = {
28699 (char *) "dest",(char *) "event", NULL
28700 };
28701
28702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28704 if (!SWIG_IsOK(res1)) {
28705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28706 }
28707 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28708 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28709 if (!SWIG_IsOK(res2)) {
28710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28711 }
28712 if (!argp2) {
28713 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28714 }
28715 arg2 = reinterpret_cast< wxEvent * >(argp2);
28716 {
28717 PyThreadState* __tstate = wxPyBeginAllowThreads();
28718 wxPostEvent(arg1,*arg2);
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 resultobj = SWIG_Py_Void();
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28730 PyObject *resultobj = 0;
28731
28732 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 wxApp_CleanUp();
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 resultobj = SWIG_Py_Void();
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28747 PyObject *resultobj = 0;
28748 wxPyApp *result = 0 ;
28749
28750 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (wxPyApp *)wxPyGetApp();
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 {
28758 resultobj = wxPyMake_wxObject(result, 0);
28759 }
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj = 0;
28768 char *arg1 = (char *) 0 ;
28769 int res1 ;
28770 char *buf1 = 0 ;
28771 int alloc1 = 0 ;
28772 PyObject * obj0 = 0 ;
28773 char * kwnames[] = {
28774 (char *) "encoding", NULL
28775 };
28776
28777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28778 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28779 if (!SWIG_IsOK(res1)) {
28780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28781 }
28782 arg1 = buf1;
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 wxSetDefaultPyEncoding((char const *)arg1);
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_Py_Void();
28790 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28791 return resultobj;
28792 fail:
28793 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28794 return NULL;
28795 }
28796
28797
28798 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28799 PyObject *resultobj = 0;
28800 char *result = 0 ;
28801
28802 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 result = (char *)wxGetDefaultPyEncoding();
28806 wxPyEndAllowThreads(__tstate);
28807 if (PyErr_Occurred()) SWIG_fail;
28808 }
28809 resultobj = SWIG_FromCharPtr(result);
28810 return resultobj;
28811 fail:
28812 return NULL;
28813 }
28814
28815
28816 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28817 PyObject *resultobj = 0;
28818 wxEventLoop *result = 0 ;
28819
28820 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 result = (wxEventLoop *)new wxEventLoop();
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28828 return resultobj;
28829 fail:
28830 return NULL;
28831 }
28832
28833
28834 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28835 PyObject *resultobj = 0;
28836 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28837 void *argp1 = 0 ;
28838 int res1 = 0 ;
28839 PyObject *swig_obj[1] ;
28840
28841 if (!args) SWIG_fail;
28842 swig_obj[0] = args;
28843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28844 if (!SWIG_IsOK(res1)) {
28845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28846 }
28847 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28848 {
28849 PyThreadState* __tstate = wxPyBeginAllowThreads();
28850 delete arg1;
28851
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 resultobj = SWIG_Py_Void();
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28863 PyObject *resultobj = 0;
28864 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28865 int result;
28866 void *argp1 = 0 ;
28867 int res1 = 0 ;
28868 PyObject *swig_obj[1] ;
28869
28870 if (!args) SWIG_fail;
28871 swig_obj[0] = args;
28872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28875 }
28876 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = (int)(arg1)->Run();
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_From_int(static_cast< int >(result));
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj = 0;
28892 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28893 int arg2 = (int) 0 ;
28894 void *argp1 = 0 ;
28895 int res1 = 0 ;
28896 int val2 ;
28897 int ecode2 = 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 char * kwnames[] = {
28901 (char *) "self",(char *) "rc", NULL
28902 };
28903
28904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28908 }
28909 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28910 if (obj1) {
28911 ecode2 = SWIG_AsVal_int(obj1, &val2);
28912 if (!SWIG_IsOK(ecode2)) {
28913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28914 }
28915 arg2 = static_cast< int >(val2);
28916 }
28917 {
28918 PyThreadState* __tstate = wxPyBeginAllowThreads();
28919 (arg1)->Exit(arg2);
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 resultobj = SWIG_Py_Void();
28924 return resultobj;
28925 fail:
28926 return NULL;
28927 }
28928
28929
28930 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28931 PyObject *resultobj = 0;
28932 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28933 bool result;
28934 void *argp1 = 0 ;
28935 int res1 = 0 ;
28936 PyObject *swig_obj[1] ;
28937
28938 if (!args) SWIG_fail;
28939 swig_obj[0] = args;
28940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28941 if (!SWIG_IsOK(res1)) {
28942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28943 }
28944 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (bool)((wxEventLoop const *)arg1)->Pending();
28948 wxPyEndAllowThreads(__tstate);
28949 if (PyErr_Occurred()) SWIG_fail;
28950 }
28951 {
28952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28953 }
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28961 PyObject *resultobj = 0;
28962 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28963 bool result;
28964 void *argp1 = 0 ;
28965 int res1 = 0 ;
28966 PyObject *swig_obj[1] ;
28967
28968 if (!args) SWIG_fail;
28969 swig_obj[0] = args;
28970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28971 if (!SWIG_IsOK(res1)) {
28972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28973 }
28974 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28975 {
28976 PyThreadState* __tstate = wxPyBeginAllowThreads();
28977 result = (bool)(arg1)->Dispatch();
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 {
28982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28983 }
28984 return resultobj;
28985 fail:
28986 return NULL;
28987 }
28988
28989
28990 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28991 PyObject *resultobj = 0;
28992 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28993 bool result;
28994 void *argp1 = 0 ;
28995 int res1 = 0 ;
28996 PyObject *swig_obj[1] ;
28997
28998 if (!args) SWIG_fail;
28999 swig_obj[0] = args;
29000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29001 if (!SWIG_IsOK(res1)) {
29002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29003 }
29004 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29005 {
29006 PyThreadState* __tstate = wxPyBeginAllowThreads();
29007 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29008 wxPyEndAllowThreads(__tstate);
29009 if (PyErr_Occurred()) SWIG_fail;
29010 }
29011 {
29012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29013 }
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29021 PyObject *resultobj = 0;
29022 wxEventLoop *result = 0 ;
29023
29024 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29025 {
29026 PyThreadState* __tstate = wxPyBeginAllowThreads();
29027 result = (wxEventLoop *)wxEventLoop::GetActive();
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29039 PyObject *resultobj = 0;
29040 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29041 void *argp1 = 0 ;
29042 int res1 = 0 ;
29043 PyObject * obj0 = 0 ;
29044 char * kwnames[] = {
29045 (char *) "loop", NULL
29046 };
29047
29048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29050 if (!SWIG_IsOK(res1)) {
29051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29052 }
29053 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29054 {
29055 PyThreadState* __tstate = wxPyBeginAllowThreads();
29056 wxEventLoop::SetActive(arg1);
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 resultobj = SWIG_Py_Void();
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *obj;
29069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29070 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29071 return SWIG_Py_Void();
29072 }
29073
29074 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29075 return SWIG_Python_InitShadowInstance(args);
29076 }
29077
29078 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj = 0;
29080 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29081 wxEventLoopActivator *result = 0 ;
29082 void *argp1 = 0 ;
29083 int res1 = 0 ;
29084 PyObject * obj0 = 0 ;
29085 char * kwnames[] = {
29086 (char *) "evtLoop", NULL
29087 };
29088
29089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29091 if (!SWIG_IsOK(res1)) {
29092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29093 }
29094 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29095 {
29096 PyThreadState* __tstate = wxPyBeginAllowThreads();
29097 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29109 PyObject *resultobj = 0;
29110 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29111 void *argp1 = 0 ;
29112 int res1 = 0 ;
29113 PyObject *swig_obj[1] ;
29114
29115 if (!args) SWIG_fail;
29116 swig_obj[0] = args;
29117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29118 if (!SWIG_IsOK(res1)) {
29119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29120 }
29121 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29122 {
29123 PyThreadState* __tstate = wxPyBeginAllowThreads();
29124 delete arg1;
29125
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 resultobj = SWIG_Py_Void();
29130 return resultobj;
29131 fail:
29132 return NULL;
29133 }
29134
29135
29136 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29137 PyObject *obj;
29138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29139 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29140 return SWIG_Py_Void();
29141 }
29142
29143 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29144 return SWIG_Python_InitShadowInstance(args);
29145 }
29146
29147 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29148 PyObject *resultobj = 0;
29149 int arg1 = (int) 0 ;
29150 int arg2 = (int) 0 ;
29151 int arg3 = (int) 0 ;
29152 wxAcceleratorEntry *result = 0 ;
29153 int val1 ;
29154 int ecode1 = 0 ;
29155 int val2 ;
29156 int ecode2 = 0 ;
29157 int val3 ;
29158 int ecode3 = 0 ;
29159 PyObject * obj0 = 0 ;
29160 PyObject * obj1 = 0 ;
29161 PyObject * obj2 = 0 ;
29162 char * kwnames[] = {
29163 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29164 };
29165
29166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29167 if (obj0) {
29168 ecode1 = SWIG_AsVal_int(obj0, &val1);
29169 if (!SWIG_IsOK(ecode1)) {
29170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29171 }
29172 arg1 = static_cast< int >(val1);
29173 }
29174 if (obj1) {
29175 ecode2 = SWIG_AsVal_int(obj1, &val2);
29176 if (!SWIG_IsOK(ecode2)) {
29177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29178 }
29179 arg2 = static_cast< int >(val2);
29180 }
29181 if (obj2) {
29182 ecode3 = SWIG_AsVal_int(obj2, &val3);
29183 if (!SWIG_IsOK(ecode3)) {
29184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29185 }
29186 arg3 = static_cast< int >(val3);
29187 }
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29191 wxPyEndAllowThreads(__tstate);
29192 if (PyErr_Occurred()) SWIG_fail;
29193 }
29194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29195 return resultobj;
29196 fail:
29197 return NULL;
29198 }
29199
29200
29201 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29202 PyObject *resultobj = 0;
29203 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29204 void *argp1 = 0 ;
29205 int res1 = 0 ;
29206 PyObject *swig_obj[1] ;
29207
29208 if (!args) SWIG_fail;
29209 swig_obj[0] = args;
29210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29211 if (!SWIG_IsOK(res1)) {
29212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29213 }
29214 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 delete arg1;
29218
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 resultobj = SWIG_Py_Void();
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29230 PyObject *resultobj = 0;
29231 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29232 int arg2 ;
29233 int arg3 ;
29234 int arg4 ;
29235 void *argp1 = 0 ;
29236 int res1 = 0 ;
29237 int val2 ;
29238 int ecode2 = 0 ;
29239 int val3 ;
29240 int ecode3 = 0 ;
29241 int val4 ;
29242 int ecode4 = 0 ;
29243 PyObject * obj0 = 0 ;
29244 PyObject * obj1 = 0 ;
29245 PyObject * obj2 = 0 ;
29246 PyObject * obj3 = 0 ;
29247 char * kwnames[] = {
29248 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29249 };
29250
29251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29253 if (!SWIG_IsOK(res1)) {
29254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29255 }
29256 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29257 ecode2 = SWIG_AsVal_int(obj1, &val2);
29258 if (!SWIG_IsOK(ecode2)) {
29259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29260 }
29261 arg2 = static_cast< int >(val2);
29262 ecode3 = SWIG_AsVal_int(obj2, &val3);
29263 if (!SWIG_IsOK(ecode3)) {
29264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29265 }
29266 arg3 = static_cast< int >(val3);
29267 ecode4 = SWIG_AsVal_int(obj3, &val4);
29268 if (!SWIG_IsOK(ecode4)) {
29269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29270 }
29271 arg4 = static_cast< int >(val4);
29272 {
29273 PyThreadState* __tstate = wxPyBeginAllowThreads();
29274 (arg1)->Set(arg2,arg3,arg4);
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 resultobj = SWIG_Py_Void();
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29286 PyObject *resultobj = 0;
29287 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29288 int result;
29289 void *argp1 = 0 ;
29290 int res1 = 0 ;
29291 PyObject *swig_obj[1] ;
29292
29293 if (!args) SWIG_fail;
29294 swig_obj[0] = args;
29295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29296 if (!SWIG_IsOK(res1)) {
29297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29298 }
29299 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 result = (int)(arg1)->GetFlags();
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 resultobj = SWIG_From_int(static_cast< int >(result));
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29314 PyObject *resultobj = 0;
29315 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29316 int result;
29317 void *argp1 = 0 ;
29318 int res1 = 0 ;
29319 PyObject *swig_obj[1] ;
29320
29321 if (!args) SWIG_fail;
29322 swig_obj[0] = args;
29323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29324 if (!SWIG_IsOK(res1)) {
29325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29326 }
29327 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29328 {
29329 PyThreadState* __tstate = wxPyBeginAllowThreads();
29330 result = (int)(arg1)->GetKeyCode();
29331 wxPyEndAllowThreads(__tstate);
29332 if (PyErr_Occurred()) SWIG_fail;
29333 }
29334 resultobj = SWIG_From_int(static_cast< int >(result));
29335 return resultobj;
29336 fail:
29337 return NULL;
29338 }
29339
29340
29341 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29342 PyObject *resultobj = 0;
29343 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29344 int result;
29345 void *argp1 = 0 ;
29346 int res1 = 0 ;
29347 PyObject *swig_obj[1] ;
29348
29349 if (!args) SWIG_fail;
29350 swig_obj[0] = args;
29351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29352 if (!SWIG_IsOK(res1)) {
29353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29354 }
29355 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 result = (int)(arg1)->GetCommand();
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 resultobj = SWIG_From_int(static_cast< int >(result));
29363 return resultobj;
29364 fail:
29365 return NULL;
29366 }
29367
29368
29369 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29370 PyObject *obj;
29371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29372 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29373 return SWIG_Py_Void();
29374 }
29375
29376 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29377 return SWIG_Python_InitShadowInstance(args);
29378 }
29379
29380 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29381 PyObject *resultobj = 0;
29382 int arg1 ;
29383 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29384 wxAcceleratorTable *result = 0 ;
29385 PyObject * obj0 = 0 ;
29386 char * kwnames[] = {
29387 (char *) "n", NULL
29388 };
29389
29390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29391 {
29392 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29393 if (arg2) arg1 = PyList_Size(obj0);
29394 else arg1 = 0;
29395 }
29396 {
29397 PyThreadState* __tstate = wxPyBeginAllowThreads();
29398 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29399 wxPyEndAllowThreads(__tstate);
29400 if (PyErr_Occurred()) SWIG_fail;
29401 }
29402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29410 PyObject *resultobj = 0;
29411 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29412 void *argp1 = 0 ;
29413 int res1 = 0 ;
29414 PyObject *swig_obj[1] ;
29415
29416 if (!args) SWIG_fail;
29417 swig_obj[0] = args;
29418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29419 if (!SWIG_IsOK(res1)) {
29420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29421 }
29422 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29423 {
29424 PyThreadState* __tstate = wxPyBeginAllowThreads();
29425 delete arg1;
29426
29427 wxPyEndAllowThreads(__tstate);
29428 if (PyErr_Occurred()) SWIG_fail;
29429 }
29430 resultobj = SWIG_Py_Void();
29431 return resultobj;
29432 fail:
29433 return NULL;
29434 }
29435
29436
29437 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29438 PyObject *resultobj = 0;
29439 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29440 bool result;
29441 void *argp1 = 0 ;
29442 int res1 = 0 ;
29443 PyObject *swig_obj[1] ;
29444
29445 if (!args) SWIG_fail;
29446 swig_obj[0] = args;
29447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29448 if (!SWIG_IsOK(res1)) {
29449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29450 }
29451 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29452 {
29453 PyThreadState* __tstate = wxPyBeginAllowThreads();
29454 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29455 wxPyEndAllowThreads(__tstate);
29456 if (PyErr_Occurred()) SWIG_fail;
29457 }
29458 {
29459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29460 }
29461 return resultobj;
29462 fail:
29463 return NULL;
29464 }
29465
29466
29467 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29468 PyObject *obj;
29469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29470 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29471 return SWIG_Py_Void();
29472 }
29473
29474 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 return SWIG_Python_InitShadowInstance(args);
29476 }
29477
29478 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29479 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29480 return 1;
29481 }
29482
29483
29484 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29485 PyObject *pyobj = 0;
29486
29487 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29488 return pyobj;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj = 0;
29494 wxString *arg1 = 0 ;
29495 wxAcceleratorEntry *result = 0 ;
29496 bool temp1 = false ;
29497 PyObject * obj0 = 0 ;
29498 char * kwnames[] = {
29499 (char *) "label", NULL
29500 };
29501
29502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29503 {
29504 arg1 = wxString_in_helper(obj0);
29505 if (arg1 == NULL) SWIG_fail;
29506 temp1 = true;
29507 }
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29511 wxPyEndAllowThreads(__tstate);
29512 if (PyErr_Occurred()) SWIG_fail;
29513 }
29514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29515 {
29516 if (temp1)
29517 delete arg1;
29518 }
29519 return resultobj;
29520 fail:
29521 {
29522 if (temp1)
29523 delete arg1;
29524 }
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN int PanelNameStr_set(PyObject *) {
29530 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29531 return 1;
29532 }
29533
29534
29535 SWIGINTERN PyObject *PanelNameStr_get(void) {
29536 PyObject *pyobj = 0;
29537
29538 {
29539 #if wxUSE_UNICODE
29540 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29541 #else
29542 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29543 #endif
29544 }
29545 return pyobj;
29546 }
29547
29548
29549 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29550 PyObject *resultobj = 0;
29551 wxVisualAttributes *result = 0 ;
29552
29553 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29554 {
29555 PyThreadState* __tstate = wxPyBeginAllowThreads();
29556 result = (wxVisualAttributes *)new_wxVisualAttributes();
29557 wxPyEndAllowThreads(__tstate);
29558 if (PyErr_Occurred()) SWIG_fail;
29559 }
29560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29561 return resultobj;
29562 fail:
29563 return NULL;
29564 }
29565
29566
29567 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29568 PyObject *resultobj = 0;
29569 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29570 void *argp1 = 0 ;
29571 int res1 = 0 ;
29572 PyObject *swig_obj[1] ;
29573
29574 if (!args) SWIG_fail;
29575 swig_obj[0] = args;
29576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29577 if (!SWIG_IsOK(res1)) {
29578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29579 }
29580 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29581 {
29582 PyThreadState* __tstate = wxPyBeginAllowThreads();
29583 delete_wxVisualAttributes(arg1);
29584
29585 wxPyEndAllowThreads(__tstate);
29586 if (PyErr_Occurred()) SWIG_fail;
29587 }
29588 resultobj = SWIG_Py_Void();
29589 return resultobj;
29590 fail:
29591 return NULL;
29592 }
29593
29594
29595 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29596 PyObject *resultobj = 0;
29597 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29598 wxFont *arg2 = (wxFont *) 0 ;
29599 void *argp1 = 0 ;
29600 int res1 = 0 ;
29601 void *argp2 = 0 ;
29602 int res2 = 0 ;
29603 PyObject *swig_obj[2] ;
29604
29605 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29607 if (!SWIG_IsOK(res1)) {
29608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29609 }
29610 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29611 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29612 if (!SWIG_IsOK(res2)) {
29613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29614 }
29615 arg2 = reinterpret_cast< wxFont * >(argp2);
29616 if (arg1) (arg1)->font = *arg2;
29617
29618 resultobj = SWIG_Py_Void();
29619 return resultobj;
29620 fail:
29621 return NULL;
29622 }
29623
29624
29625 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29626 PyObject *resultobj = 0;
29627 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29628 wxFont *result = 0 ;
29629 void *argp1 = 0 ;
29630 int res1 = 0 ;
29631 PyObject *swig_obj[1] ;
29632
29633 if (!args) SWIG_fail;
29634 swig_obj[0] = args;
29635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29636 if (!SWIG_IsOK(res1)) {
29637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29638 }
29639 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29640 result = (wxFont *)& ((arg1)->font);
29641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29649 PyObject *resultobj = 0;
29650 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29651 wxColour *arg2 = (wxColour *) 0 ;
29652 void *argp1 = 0 ;
29653 int res1 = 0 ;
29654 void *argp2 = 0 ;
29655 int res2 = 0 ;
29656 PyObject *swig_obj[2] ;
29657
29658 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29660 if (!SWIG_IsOK(res1)) {
29661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29662 }
29663 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29664 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29665 if (!SWIG_IsOK(res2)) {
29666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29667 }
29668 arg2 = reinterpret_cast< wxColour * >(argp2);
29669 if (arg1) (arg1)->colFg = *arg2;
29670
29671 resultobj = SWIG_Py_Void();
29672 return resultobj;
29673 fail:
29674 return NULL;
29675 }
29676
29677
29678 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29679 PyObject *resultobj = 0;
29680 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29681 wxColour *result = 0 ;
29682 void *argp1 = 0 ;
29683 int res1 = 0 ;
29684 PyObject *swig_obj[1] ;
29685
29686 if (!args) SWIG_fail;
29687 swig_obj[0] = args;
29688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29689 if (!SWIG_IsOK(res1)) {
29690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29691 }
29692 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29693 result = (wxColour *)& ((arg1)->colFg);
29694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29695 return resultobj;
29696 fail:
29697 return NULL;
29698 }
29699
29700
29701 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29702 PyObject *resultobj = 0;
29703 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29704 wxColour *arg2 = (wxColour *) 0 ;
29705 void *argp1 = 0 ;
29706 int res1 = 0 ;
29707 void *argp2 = 0 ;
29708 int res2 = 0 ;
29709 PyObject *swig_obj[2] ;
29710
29711 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29713 if (!SWIG_IsOK(res1)) {
29714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29715 }
29716 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29717 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29718 if (!SWIG_IsOK(res2)) {
29719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29720 }
29721 arg2 = reinterpret_cast< wxColour * >(argp2);
29722 if (arg1) (arg1)->colBg = *arg2;
29723
29724 resultobj = SWIG_Py_Void();
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29732 PyObject *resultobj = 0;
29733 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29734 wxColour *result = 0 ;
29735 void *argp1 = 0 ;
29736 int res1 = 0 ;
29737 PyObject *swig_obj[1] ;
29738
29739 if (!args) SWIG_fail;
29740 swig_obj[0] = args;
29741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29742 if (!SWIG_IsOK(res1)) {
29743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29744 }
29745 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29746 result = (wxColour *)& ((arg1)->colBg);
29747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29748 return resultobj;
29749 fail:
29750 return NULL;
29751 }
29752
29753
29754 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 PyObject *obj;
29756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29757 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29758 return SWIG_Py_Void();
29759 }
29760
29761 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29762 return SWIG_Python_InitShadowInstance(args);
29763 }
29764
29765 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29766 PyObject *resultobj = 0;
29767 wxWindow *arg1 = (wxWindow *) 0 ;
29768 int arg2 = (int) (int)-1 ;
29769 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29770 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29771 wxSize const &arg4_defvalue = wxDefaultSize ;
29772 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29773 long arg5 = (long) 0 ;
29774 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29775 wxString *arg6 = (wxString *) &arg6_defvalue ;
29776 wxWindow *result = 0 ;
29777 void *argp1 = 0 ;
29778 int res1 = 0 ;
29779 int val2 ;
29780 int ecode2 = 0 ;
29781 wxPoint temp3 ;
29782 wxSize temp4 ;
29783 long val5 ;
29784 int ecode5 = 0 ;
29785 bool temp6 = false ;
29786 PyObject * obj0 = 0 ;
29787 PyObject * obj1 = 0 ;
29788 PyObject * obj2 = 0 ;
29789 PyObject * obj3 = 0 ;
29790 PyObject * obj4 = 0 ;
29791 PyObject * obj5 = 0 ;
29792 char * kwnames[] = {
29793 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29794 };
29795
29796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29798 if (!SWIG_IsOK(res1)) {
29799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29800 }
29801 arg1 = reinterpret_cast< wxWindow * >(argp1);
29802 if (obj1) {
29803 ecode2 = SWIG_AsVal_int(obj1, &val2);
29804 if (!SWIG_IsOK(ecode2)) {
29805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29806 }
29807 arg2 = static_cast< int >(val2);
29808 }
29809 if (obj2) {
29810 {
29811 arg3 = &temp3;
29812 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29813 }
29814 }
29815 if (obj3) {
29816 {
29817 arg4 = &temp4;
29818 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29819 }
29820 }
29821 if (obj4) {
29822 ecode5 = SWIG_AsVal_long(obj4, &val5);
29823 if (!SWIG_IsOK(ecode5)) {
29824 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29825 }
29826 arg5 = static_cast< long >(val5);
29827 }
29828 if (obj5) {
29829 {
29830 arg6 = wxString_in_helper(obj5);
29831 if (arg6 == NULL) SWIG_fail;
29832 temp6 = true;
29833 }
29834 }
29835 {
29836 if (!wxPyCheckForApp()) SWIG_fail;
29837 PyThreadState* __tstate = wxPyBeginAllowThreads();
29838 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29839 wxPyEndAllowThreads(__tstate);
29840 if (PyErr_Occurred()) SWIG_fail;
29841 }
29842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29843 {
29844 if (temp6)
29845 delete arg6;
29846 }
29847 return resultobj;
29848 fail:
29849 {
29850 if (temp6)
29851 delete arg6;
29852 }
29853 return NULL;
29854 }
29855
29856
29857 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29858 PyObject *resultobj = 0;
29859 wxWindow *result = 0 ;
29860
29861 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29862 {
29863 if (!wxPyCheckForApp()) SWIG_fail;
29864 PyThreadState* __tstate = wxPyBeginAllowThreads();
29865 result = (wxWindow *)new wxWindow();
29866 wxPyEndAllowThreads(__tstate);
29867 if (PyErr_Occurred()) SWIG_fail;
29868 }
29869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29870 return resultobj;
29871 fail:
29872 return NULL;
29873 }
29874
29875
29876 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29877 PyObject *resultobj = 0;
29878 wxWindow *arg1 = (wxWindow *) 0 ;
29879 wxWindow *arg2 = (wxWindow *) 0 ;
29880 int arg3 = (int) (int)-1 ;
29881 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29882 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29883 wxSize const &arg5_defvalue = wxDefaultSize ;
29884 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29885 long arg6 = (long) 0 ;
29886 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29887 wxString *arg7 = (wxString *) &arg7_defvalue ;
29888 bool result;
29889 void *argp1 = 0 ;
29890 int res1 = 0 ;
29891 void *argp2 = 0 ;
29892 int res2 = 0 ;
29893 int val3 ;
29894 int ecode3 = 0 ;
29895 wxPoint temp4 ;
29896 wxSize temp5 ;
29897 long val6 ;
29898 int ecode6 = 0 ;
29899 bool temp7 = false ;
29900 PyObject * obj0 = 0 ;
29901 PyObject * obj1 = 0 ;
29902 PyObject * obj2 = 0 ;
29903 PyObject * obj3 = 0 ;
29904 PyObject * obj4 = 0 ;
29905 PyObject * obj5 = 0 ;
29906 PyObject * obj6 = 0 ;
29907 char * kwnames[] = {
29908 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29909 };
29910
29911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29913 if (!SWIG_IsOK(res1)) {
29914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29915 }
29916 arg1 = reinterpret_cast< wxWindow * >(argp1);
29917 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29918 if (!SWIG_IsOK(res2)) {
29919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29920 }
29921 arg2 = reinterpret_cast< wxWindow * >(argp2);
29922 if (obj2) {
29923 ecode3 = SWIG_AsVal_int(obj2, &val3);
29924 if (!SWIG_IsOK(ecode3)) {
29925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29926 }
29927 arg3 = static_cast< int >(val3);
29928 }
29929 if (obj3) {
29930 {
29931 arg4 = &temp4;
29932 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29933 }
29934 }
29935 if (obj4) {
29936 {
29937 arg5 = &temp5;
29938 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29939 }
29940 }
29941 if (obj5) {
29942 ecode6 = SWIG_AsVal_long(obj5, &val6);
29943 if (!SWIG_IsOK(ecode6)) {
29944 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29945 }
29946 arg6 = static_cast< long >(val6);
29947 }
29948 if (obj6) {
29949 {
29950 arg7 = wxString_in_helper(obj6);
29951 if (arg7 == NULL) SWIG_fail;
29952 temp7 = true;
29953 }
29954 }
29955 {
29956 PyThreadState* __tstate = wxPyBeginAllowThreads();
29957 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29958 wxPyEndAllowThreads(__tstate);
29959 if (PyErr_Occurred()) SWIG_fail;
29960 }
29961 {
29962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29963 }
29964 {
29965 if (temp7)
29966 delete arg7;
29967 }
29968 return resultobj;
29969 fail:
29970 {
29971 if (temp7)
29972 delete arg7;
29973 }
29974 return NULL;
29975 }
29976
29977
29978 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29979 PyObject *resultobj = 0;
29980 wxWindow *arg1 = (wxWindow *) 0 ;
29981 bool arg2 = (bool) false ;
29982 bool result;
29983 void *argp1 = 0 ;
29984 int res1 = 0 ;
29985 bool val2 ;
29986 int ecode2 = 0 ;
29987 PyObject * obj0 = 0 ;
29988 PyObject * obj1 = 0 ;
29989 char * kwnames[] = {
29990 (char *) "self",(char *) "force", NULL
29991 };
29992
29993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29995 if (!SWIG_IsOK(res1)) {
29996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29997 }
29998 arg1 = reinterpret_cast< wxWindow * >(argp1);
29999 if (obj1) {
30000 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30001 if (!SWIG_IsOK(ecode2)) {
30002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30003 }
30004 arg2 = static_cast< bool >(val2);
30005 }
30006 {
30007 PyThreadState* __tstate = wxPyBeginAllowThreads();
30008 result = (bool)(arg1)->Close(arg2);
30009 wxPyEndAllowThreads(__tstate);
30010 if (PyErr_Occurred()) SWIG_fail;
30011 }
30012 {
30013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30014 }
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30022 PyObject *resultobj = 0;
30023 wxWindow *arg1 = (wxWindow *) 0 ;
30024 bool result;
30025 void *argp1 = 0 ;
30026 int res1 = 0 ;
30027 PyObject *swig_obj[1] ;
30028
30029 if (!args) SWIG_fail;
30030 swig_obj[0] = args;
30031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30032 if (!SWIG_IsOK(res1)) {
30033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30034 }
30035 arg1 = reinterpret_cast< wxWindow * >(argp1);
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 result = (bool)(arg1)->Destroy();
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 {
30043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30044 }
30045 return resultobj;
30046 fail:
30047 return NULL;
30048 }
30049
30050
30051 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30052 PyObject *resultobj = 0;
30053 wxWindow *arg1 = (wxWindow *) 0 ;
30054 bool result;
30055 void *argp1 = 0 ;
30056 int res1 = 0 ;
30057 PyObject *swig_obj[1] ;
30058
30059 if (!args) SWIG_fail;
30060 swig_obj[0] = args;
30061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30062 if (!SWIG_IsOK(res1)) {
30063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30064 }
30065 arg1 = reinterpret_cast< wxWindow * >(argp1);
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = (bool)(arg1)->DestroyChildren();
30069 wxPyEndAllowThreads(__tstate);
30070 if (PyErr_Occurred()) SWIG_fail;
30071 }
30072 {
30073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30074 }
30075 return resultobj;
30076 fail:
30077 return NULL;
30078 }
30079
30080
30081 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30082 PyObject *resultobj = 0;
30083 wxWindow *arg1 = (wxWindow *) 0 ;
30084 bool result;
30085 void *argp1 = 0 ;
30086 int res1 = 0 ;
30087 PyObject *swig_obj[1] ;
30088
30089 if (!args) SWIG_fail;
30090 swig_obj[0] = args;
30091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30092 if (!SWIG_IsOK(res1)) {
30093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30094 }
30095 arg1 = reinterpret_cast< wxWindow * >(argp1);
30096 {
30097 PyThreadState* __tstate = wxPyBeginAllowThreads();
30098 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 {
30103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30104 }
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30112 PyObject *resultobj = 0;
30113 wxWindow *arg1 = (wxWindow *) 0 ;
30114 wxString *arg2 = 0 ;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 bool temp2 = false ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 char * kwnames[] = {
30121 (char *) "self",(char *) "label", NULL
30122 };
30123
30124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30126 if (!SWIG_IsOK(res1)) {
30127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30128 }
30129 arg1 = reinterpret_cast< wxWindow * >(argp1);
30130 {
30131 arg2 = wxString_in_helper(obj1);
30132 if (arg2 == NULL) SWIG_fail;
30133 temp2 = true;
30134 }
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 (arg1)->SetLabel((wxString const &)*arg2);
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 resultobj = SWIG_Py_Void();
30142 {
30143 if (temp2)
30144 delete arg2;
30145 }
30146 return resultobj;
30147 fail:
30148 {
30149 if (temp2)
30150 delete arg2;
30151 }
30152 return NULL;
30153 }
30154
30155
30156 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30157 PyObject *resultobj = 0;
30158 wxWindow *arg1 = (wxWindow *) 0 ;
30159 wxString result;
30160 void *argp1 = 0 ;
30161 int res1 = 0 ;
30162 PyObject *swig_obj[1] ;
30163
30164 if (!args) SWIG_fail;
30165 swig_obj[0] = args;
30166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30167 if (!SWIG_IsOK(res1)) {
30168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30169 }
30170 arg1 = reinterpret_cast< wxWindow * >(argp1);
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = ((wxWindow const *)arg1)->GetLabel();
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 {
30178 #if wxUSE_UNICODE
30179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30180 #else
30181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30182 #endif
30183 }
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30191 PyObject *resultobj = 0;
30192 wxWindow *arg1 = (wxWindow *) 0 ;
30193 wxString *arg2 = 0 ;
30194 void *argp1 = 0 ;
30195 int res1 = 0 ;
30196 bool temp2 = false ;
30197 PyObject * obj0 = 0 ;
30198 PyObject * obj1 = 0 ;
30199 char * kwnames[] = {
30200 (char *) "self",(char *) "name", NULL
30201 };
30202
30203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30205 if (!SWIG_IsOK(res1)) {
30206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30207 }
30208 arg1 = reinterpret_cast< wxWindow * >(argp1);
30209 {
30210 arg2 = wxString_in_helper(obj1);
30211 if (arg2 == NULL) SWIG_fail;
30212 temp2 = true;
30213 }
30214 {
30215 PyThreadState* __tstate = wxPyBeginAllowThreads();
30216 (arg1)->SetName((wxString const &)*arg2);
30217 wxPyEndAllowThreads(__tstate);
30218 if (PyErr_Occurred()) SWIG_fail;
30219 }
30220 resultobj = SWIG_Py_Void();
30221 {
30222 if (temp2)
30223 delete arg2;
30224 }
30225 return resultobj;
30226 fail:
30227 {
30228 if (temp2)
30229 delete arg2;
30230 }
30231 return NULL;
30232 }
30233
30234
30235 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30236 PyObject *resultobj = 0;
30237 wxWindow *arg1 = (wxWindow *) 0 ;
30238 wxString result;
30239 void *argp1 = 0 ;
30240 int res1 = 0 ;
30241 PyObject *swig_obj[1] ;
30242
30243 if (!args) SWIG_fail;
30244 swig_obj[0] = args;
30245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30246 if (!SWIG_IsOK(res1)) {
30247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30248 }
30249 arg1 = reinterpret_cast< wxWindow * >(argp1);
30250 {
30251 PyThreadState* __tstate = wxPyBeginAllowThreads();
30252 result = ((wxWindow const *)arg1)->GetName();
30253 wxPyEndAllowThreads(__tstate);
30254 if (PyErr_Occurred()) SWIG_fail;
30255 }
30256 {
30257 #if wxUSE_UNICODE
30258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30259 #else
30260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30261 #endif
30262 }
30263 return resultobj;
30264 fail:
30265 return NULL;
30266 }
30267
30268
30269 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30270 PyObject *resultobj = 0;
30271 wxWindow *arg1 = (wxWindow *) 0 ;
30272 wxWindowVariant arg2 ;
30273 void *argp1 = 0 ;
30274 int res1 = 0 ;
30275 int val2 ;
30276 int ecode2 = 0 ;
30277 PyObject * obj0 = 0 ;
30278 PyObject * obj1 = 0 ;
30279 char * kwnames[] = {
30280 (char *) "self",(char *) "variant", NULL
30281 };
30282
30283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30285 if (!SWIG_IsOK(res1)) {
30286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30287 }
30288 arg1 = reinterpret_cast< wxWindow * >(argp1);
30289 ecode2 = SWIG_AsVal_int(obj1, &val2);
30290 if (!SWIG_IsOK(ecode2)) {
30291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30292 }
30293 arg2 = static_cast< wxWindowVariant >(val2);
30294 {
30295 PyThreadState* __tstate = wxPyBeginAllowThreads();
30296 (arg1)->SetWindowVariant(arg2);
30297 wxPyEndAllowThreads(__tstate);
30298 if (PyErr_Occurred()) SWIG_fail;
30299 }
30300 resultobj = SWIG_Py_Void();
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30308 PyObject *resultobj = 0;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 wxWindowVariant result;
30311 void *argp1 = 0 ;
30312 int res1 = 0 ;
30313 PyObject *swig_obj[1] ;
30314
30315 if (!args) SWIG_fail;
30316 swig_obj[0] = args;
30317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30318 if (!SWIG_IsOK(res1)) {
30319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30320 }
30321 arg1 = reinterpret_cast< wxWindow * >(argp1);
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 resultobj = SWIG_From_int(static_cast< int >(result));
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30336 PyObject *resultobj = 0;
30337 wxWindow *arg1 = (wxWindow *) 0 ;
30338 int arg2 ;
30339 void *argp1 = 0 ;
30340 int res1 = 0 ;
30341 int val2 ;
30342 int ecode2 = 0 ;
30343 PyObject * obj0 = 0 ;
30344 PyObject * obj1 = 0 ;
30345 char * kwnames[] = {
30346 (char *) "self",(char *) "winid", NULL
30347 };
30348
30349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30351 if (!SWIG_IsOK(res1)) {
30352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30353 }
30354 arg1 = reinterpret_cast< wxWindow * >(argp1);
30355 ecode2 = SWIG_AsVal_int(obj1, &val2);
30356 if (!SWIG_IsOK(ecode2)) {
30357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30358 }
30359 arg2 = static_cast< int >(val2);
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 (arg1)->SetId(arg2);
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 resultobj = SWIG_Py_Void();
30367 return resultobj;
30368 fail:
30369 return NULL;
30370 }
30371
30372
30373 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30374 PyObject *resultobj = 0;
30375 wxWindow *arg1 = (wxWindow *) 0 ;
30376 int result;
30377 void *argp1 = 0 ;
30378 int res1 = 0 ;
30379 PyObject *swig_obj[1] ;
30380
30381 if (!args) SWIG_fail;
30382 swig_obj[0] = args;
30383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30384 if (!SWIG_IsOK(res1)) {
30385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30386 }
30387 arg1 = reinterpret_cast< wxWindow * >(argp1);
30388 {
30389 PyThreadState* __tstate = wxPyBeginAllowThreads();
30390 result = (int)((wxWindow const *)arg1)->GetId();
30391 wxPyEndAllowThreads(__tstate);
30392 if (PyErr_Occurred()) SWIG_fail;
30393 }
30394 resultobj = SWIG_From_int(static_cast< int >(result));
30395 return resultobj;
30396 fail:
30397 return NULL;
30398 }
30399
30400
30401 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30402 PyObject *resultobj = 0;
30403 int result;
30404
30405 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 result = (int)wxWindow::NewControlId();
30409 wxPyEndAllowThreads(__tstate);
30410 if (PyErr_Occurred()) SWIG_fail;
30411 }
30412 resultobj = SWIG_From_int(static_cast< int >(result));
30413 return resultobj;
30414 fail:
30415 return NULL;
30416 }
30417
30418
30419 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30420 PyObject *resultobj = 0;
30421 int arg1 ;
30422 int result;
30423 int val1 ;
30424 int ecode1 = 0 ;
30425 PyObject * obj0 = 0 ;
30426 char * kwnames[] = {
30427 (char *) "winid", NULL
30428 };
30429
30430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30431 ecode1 = SWIG_AsVal_int(obj0, &val1);
30432 if (!SWIG_IsOK(ecode1)) {
30433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30434 }
30435 arg1 = static_cast< int >(val1);
30436 {
30437 PyThreadState* __tstate = wxPyBeginAllowThreads();
30438 result = (int)wxWindow::NextControlId(arg1);
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 resultobj = SWIG_From_int(static_cast< int >(result));
30443 return resultobj;
30444 fail:
30445 return NULL;
30446 }
30447
30448
30449 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30450 PyObject *resultobj = 0;
30451 int arg1 ;
30452 int result;
30453 int val1 ;
30454 int ecode1 = 0 ;
30455 PyObject * obj0 = 0 ;
30456 char * kwnames[] = {
30457 (char *) "winid", NULL
30458 };
30459
30460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30461 ecode1 = SWIG_AsVal_int(obj0, &val1);
30462 if (!SWIG_IsOK(ecode1)) {
30463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30464 }
30465 arg1 = static_cast< int >(val1);
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 result = (int)wxWindow::PrevControlId(arg1);
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 resultobj = SWIG_From_int(static_cast< int >(result));
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30480 PyObject *resultobj = 0;
30481 wxWindow *arg1 = (wxWindow *) 0 ;
30482 wxSize *arg2 = 0 ;
30483 void *argp1 = 0 ;
30484 int res1 = 0 ;
30485 wxSize temp2 ;
30486 PyObject * obj0 = 0 ;
30487 PyObject * obj1 = 0 ;
30488 char * kwnames[] = {
30489 (char *) "self",(char *) "size", NULL
30490 };
30491
30492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30494 if (!SWIG_IsOK(res1)) {
30495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30496 }
30497 arg1 = reinterpret_cast< wxWindow * >(argp1);
30498 {
30499 arg2 = &temp2;
30500 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30501 }
30502 {
30503 PyThreadState* __tstate = wxPyBeginAllowThreads();
30504 (arg1)->SetSize((wxSize const &)*arg2);
30505 wxPyEndAllowThreads(__tstate);
30506 if (PyErr_Occurred()) SWIG_fail;
30507 }
30508 resultobj = SWIG_Py_Void();
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj = 0;
30517 wxWindow *arg1 = (wxWindow *) 0 ;
30518 int arg2 ;
30519 int arg3 ;
30520 int arg4 ;
30521 int arg5 ;
30522 int arg6 = (int) wxSIZE_AUTO ;
30523 void *argp1 = 0 ;
30524 int res1 = 0 ;
30525 int val2 ;
30526 int ecode2 = 0 ;
30527 int val3 ;
30528 int ecode3 = 0 ;
30529 int val4 ;
30530 int ecode4 = 0 ;
30531 int val5 ;
30532 int ecode5 = 0 ;
30533 int val6 ;
30534 int ecode6 = 0 ;
30535 PyObject * obj0 = 0 ;
30536 PyObject * obj1 = 0 ;
30537 PyObject * obj2 = 0 ;
30538 PyObject * obj3 = 0 ;
30539 PyObject * obj4 = 0 ;
30540 PyObject * obj5 = 0 ;
30541 char * kwnames[] = {
30542 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30543 };
30544
30545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30547 if (!SWIG_IsOK(res1)) {
30548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30549 }
30550 arg1 = reinterpret_cast< wxWindow * >(argp1);
30551 ecode2 = SWIG_AsVal_int(obj1, &val2);
30552 if (!SWIG_IsOK(ecode2)) {
30553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30554 }
30555 arg2 = static_cast< int >(val2);
30556 ecode3 = SWIG_AsVal_int(obj2, &val3);
30557 if (!SWIG_IsOK(ecode3)) {
30558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30559 }
30560 arg3 = static_cast< int >(val3);
30561 ecode4 = SWIG_AsVal_int(obj3, &val4);
30562 if (!SWIG_IsOK(ecode4)) {
30563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30564 }
30565 arg4 = static_cast< int >(val4);
30566 ecode5 = SWIG_AsVal_int(obj4, &val5);
30567 if (!SWIG_IsOK(ecode5)) {
30568 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30569 }
30570 arg5 = static_cast< int >(val5);
30571 if (obj5) {
30572 ecode6 = SWIG_AsVal_int(obj5, &val6);
30573 if (!SWIG_IsOK(ecode6)) {
30574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30575 }
30576 arg6 = static_cast< int >(val6);
30577 }
30578 {
30579 PyThreadState* __tstate = wxPyBeginAllowThreads();
30580 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30581 wxPyEndAllowThreads(__tstate);
30582 if (PyErr_Occurred()) SWIG_fail;
30583 }
30584 resultobj = SWIG_Py_Void();
30585 return resultobj;
30586 fail:
30587 return NULL;
30588 }
30589
30590
30591 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30592 PyObject *resultobj = 0;
30593 wxWindow *arg1 = (wxWindow *) 0 ;
30594 wxRect *arg2 = 0 ;
30595 int arg3 = (int) wxSIZE_AUTO ;
30596 void *argp1 = 0 ;
30597 int res1 = 0 ;
30598 wxRect temp2 ;
30599 int val3 ;
30600 int ecode3 = 0 ;
30601 PyObject * obj0 = 0 ;
30602 PyObject * obj1 = 0 ;
30603 PyObject * obj2 = 0 ;
30604 char * kwnames[] = {
30605 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30606 };
30607
30608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30610 if (!SWIG_IsOK(res1)) {
30611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30612 }
30613 arg1 = reinterpret_cast< wxWindow * >(argp1);
30614 {
30615 arg2 = &temp2;
30616 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30617 }
30618 if (obj2) {
30619 ecode3 = SWIG_AsVal_int(obj2, &val3);
30620 if (!SWIG_IsOK(ecode3)) {
30621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30622 }
30623 arg3 = static_cast< int >(val3);
30624 }
30625 {
30626 PyThreadState* __tstate = wxPyBeginAllowThreads();
30627 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30628 wxPyEndAllowThreads(__tstate);
30629 if (PyErr_Occurred()) SWIG_fail;
30630 }
30631 resultobj = SWIG_Py_Void();
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj = 0;
30640 wxWindow *arg1 = (wxWindow *) 0 ;
30641 int arg2 ;
30642 int arg3 ;
30643 void *argp1 = 0 ;
30644 int res1 = 0 ;
30645 int val2 ;
30646 int ecode2 = 0 ;
30647 int val3 ;
30648 int ecode3 = 0 ;
30649 PyObject * obj0 = 0 ;
30650 PyObject * obj1 = 0 ;
30651 PyObject * obj2 = 0 ;
30652 char * kwnames[] = {
30653 (char *) "self",(char *) "width",(char *) "height", NULL
30654 };
30655
30656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30658 if (!SWIG_IsOK(res1)) {
30659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30660 }
30661 arg1 = reinterpret_cast< wxWindow * >(argp1);
30662 ecode2 = SWIG_AsVal_int(obj1, &val2);
30663 if (!SWIG_IsOK(ecode2)) {
30664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30665 }
30666 arg2 = static_cast< int >(val2);
30667 ecode3 = SWIG_AsVal_int(obj2, &val3);
30668 if (!SWIG_IsOK(ecode3)) {
30669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30670 }
30671 arg3 = static_cast< int >(val3);
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 (arg1)->SetSize(arg2,arg3);
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 resultobj = SWIG_Py_Void();
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30686 PyObject *resultobj = 0;
30687 wxWindow *arg1 = (wxWindow *) 0 ;
30688 wxPoint *arg2 = 0 ;
30689 int arg3 = (int) wxSIZE_USE_EXISTING ;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 wxPoint temp2 ;
30693 int val3 ;
30694 int ecode3 = 0 ;
30695 PyObject * obj0 = 0 ;
30696 PyObject * obj1 = 0 ;
30697 PyObject * obj2 = 0 ;
30698 char * kwnames[] = {
30699 (char *) "self",(char *) "pt",(char *) "flags", NULL
30700 };
30701
30702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30704 if (!SWIG_IsOK(res1)) {
30705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30706 }
30707 arg1 = reinterpret_cast< wxWindow * >(argp1);
30708 {
30709 arg2 = &temp2;
30710 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30711 }
30712 if (obj2) {
30713 ecode3 = SWIG_AsVal_int(obj2, &val3);
30714 if (!SWIG_IsOK(ecode3)) {
30715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30716 }
30717 arg3 = static_cast< int >(val3);
30718 }
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 (arg1)->Move((wxPoint const &)*arg2,arg3);
30722 wxPyEndAllowThreads(__tstate);
30723 if (PyErr_Occurred()) SWIG_fail;
30724 }
30725 resultobj = SWIG_Py_Void();
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30733 PyObject *resultobj = 0;
30734 wxWindow *arg1 = (wxWindow *) 0 ;
30735 int arg2 ;
30736 int arg3 ;
30737 int arg4 = (int) wxSIZE_USE_EXISTING ;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 int val2 ;
30741 int ecode2 = 0 ;
30742 int val3 ;
30743 int ecode3 = 0 ;
30744 int val4 ;
30745 int ecode4 = 0 ;
30746 PyObject * obj0 = 0 ;
30747 PyObject * obj1 = 0 ;
30748 PyObject * obj2 = 0 ;
30749 PyObject * obj3 = 0 ;
30750 char * kwnames[] = {
30751 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30752 };
30753
30754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30756 if (!SWIG_IsOK(res1)) {
30757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30758 }
30759 arg1 = reinterpret_cast< wxWindow * >(argp1);
30760 ecode2 = SWIG_AsVal_int(obj1, &val2);
30761 if (!SWIG_IsOK(ecode2)) {
30762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30763 }
30764 arg2 = static_cast< int >(val2);
30765 ecode3 = SWIG_AsVal_int(obj2, &val3);
30766 if (!SWIG_IsOK(ecode3)) {
30767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30768 }
30769 arg3 = static_cast< int >(val3);
30770 if (obj3) {
30771 ecode4 = SWIG_AsVal_int(obj3, &val4);
30772 if (!SWIG_IsOK(ecode4)) {
30773 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30774 }
30775 arg4 = static_cast< int >(val4);
30776 }
30777 {
30778 PyThreadState* __tstate = wxPyBeginAllowThreads();
30779 (arg1)->Move(arg2,arg3,arg4);
30780 wxPyEndAllowThreads(__tstate);
30781 if (PyErr_Occurred()) SWIG_fail;
30782 }
30783 resultobj = SWIG_Py_Void();
30784 return resultobj;
30785 fail:
30786 return NULL;
30787 }
30788
30789
30790 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30791 PyObject *resultobj = 0;
30792 wxWindow *arg1 = (wxWindow *) 0 ;
30793 wxSize const &arg2_defvalue = wxDefaultSize ;
30794 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30795 void *argp1 = 0 ;
30796 int res1 = 0 ;
30797 wxSize temp2 ;
30798 PyObject * obj0 = 0 ;
30799 PyObject * obj1 = 0 ;
30800 char * kwnames[] = {
30801 (char *) "self",(char *) "size", NULL
30802 };
30803
30804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30806 if (!SWIG_IsOK(res1)) {
30807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30808 }
30809 arg1 = reinterpret_cast< wxWindow * >(argp1);
30810 if (obj1) {
30811 {
30812 arg2 = &temp2;
30813 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30814 }
30815 }
30816 {
30817 PyThreadState* __tstate = wxPyBeginAllowThreads();
30818 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30819 wxPyEndAllowThreads(__tstate);
30820 if (PyErr_Occurred()) SWIG_fail;
30821 }
30822 resultobj = SWIG_Py_Void();
30823 return resultobj;
30824 fail:
30825 return NULL;
30826 }
30827
30828
30829 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30830 PyObject *resultobj = 0;
30831 wxWindow *arg1 = (wxWindow *) 0 ;
30832 void *argp1 = 0 ;
30833 int res1 = 0 ;
30834 PyObject *swig_obj[1] ;
30835
30836 if (!args) SWIG_fail;
30837 swig_obj[0] = args;
30838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30839 if (!SWIG_IsOK(res1)) {
30840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30841 }
30842 arg1 = reinterpret_cast< wxWindow * >(argp1);
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 (arg1)->Raise();
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 resultobj = SWIG_Py_Void();
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30857 PyObject *resultobj = 0;
30858 wxWindow *arg1 = (wxWindow *) 0 ;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30868 }
30869 arg1 = reinterpret_cast< wxWindow * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 (arg1)->Lower();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 resultobj = SWIG_Py_Void();
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30884 PyObject *resultobj = 0;
30885 wxWindow *arg1 = (wxWindow *) 0 ;
30886 wxSize *arg2 = 0 ;
30887 void *argp1 = 0 ;
30888 int res1 = 0 ;
30889 wxSize temp2 ;
30890 PyObject * obj0 = 0 ;
30891 PyObject * obj1 = 0 ;
30892 char * kwnames[] = {
30893 (char *) "self",(char *) "size", NULL
30894 };
30895
30896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30898 if (!SWIG_IsOK(res1)) {
30899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30900 }
30901 arg1 = reinterpret_cast< wxWindow * >(argp1);
30902 {
30903 arg2 = &temp2;
30904 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30905 }
30906 {
30907 PyThreadState* __tstate = wxPyBeginAllowThreads();
30908 (arg1)->SetClientSize((wxSize const &)*arg2);
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 resultobj = SWIG_Py_Void();
30913 return resultobj;
30914 fail:
30915 return NULL;
30916 }
30917
30918
30919 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30920 PyObject *resultobj = 0;
30921 wxWindow *arg1 = (wxWindow *) 0 ;
30922 int arg2 ;
30923 int arg3 ;
30924 void *argp1 = 0 ;
30925 int res1 = 0 ;
30926 int val2 ;
30927 int ecode2 = 0 ;
30928 int val3 ;
30929 int ecode3 = 0 ;
30930 PyObject * obj0 = 0 ;
30931 PyObject * obj1 = 0 ;
30932 PyObject * obj2 = 0 ;
30933 char * kwnames[] = {
30934 (char *) "self",(char *) "width",(char *) "height", NULL
30935 };
30936
30937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30939 if (!SWIG_IsOK(res1)) {
30940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30941 }
30942 arg1 = reinterpret_cast< wxWindow * >(argp1);
30943 ecode2 = SWIG_AsVal_int(obj1, &val2);
30944 if (!SWIG_IsOK(ecode2)) {
30945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30946 }
30947 arg2 = static_cast< int >(val2);
30948 ecode3 = SWIG_AsVal_int(obj2, &val3);
30949 if (!SWIG_IsOK(ecode3)) {
30950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30951 }
30952 arg3 = static_cast< int >(val3);
30953 {
30954 PyThreadState* __tstate = wxPyBeginAllowThreads();
30955 (arg1)->SetClientSize(arg2,arg3);
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 resultobj = SWIG_Py_Void();
30960 return resultobj;
30961 fail:
30962 return NULL;
30963 }
30964
30965
30966 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30967 PyObject *resultobj = 0;
30968 wxWindow *arg1 = (wxWindow *) 0 ;
30969 wxRect *arg2 = 0 ;
30970 void *argp1 = 0 ;
30971 int res1 = 0 ;
30972 wxRect temp2 ;
30973 PyObject * obj0 = 0 ;
30974 PyObject * obj1 = 0 ;
30975 char * kwnames[] = {
30976 (char *) "self",(char *) "rect", NULL
30977 };
30978
30979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30981 if (!SWIG_IsOK(res1)) {
30982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30983 }
30984 arg1 = reinterpret_cast< wxWindow * >(argp1);
30985 {
30986 arg2 = &temp2;
30987 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30988 }
30989 {
30990 PyThreadState* __tstate = wxPyBeginAllowThreads();
30991 (arg1)->SetClientSize((wxRect const &)*arg2);
30992 wxPyEndAllowThreads(__tstate);
30993 if (PyErr_Occurred()) SWIG_fail;
30994 }
30995 resultobj = SWIG_Py_Void();
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31003 PyObject *resultobj = 0;
31004 wxWindow *arg1 = (wxWindow *) 0 ;
31005 wxPoint result;
31006 void *argp1 = 0 ;
31007 int res1 = 0 ;
31008 PyObject *swig_obj[1] ;
31009
31010 if (!args) SWIG_fail;
31011 swig_obj[0] = args;
31012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31013 if (!SWIG_IsOK(res1)) {
31014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31015 }
31016 arg1 = reinterpret_cast< wxWindow * >(argp1);
31017 {
31018 PyThreadState* __tstate = wxPyBeginAllowThreads();
31019 result = ((wxWindow const *)arg1)->GetPosition();
31020 wxPyEndAllowThreads(__tstate);
31021 if (PyErr_Occurred()) SWIG_fail;
31022 }
31023 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31024 return resultobj;
31025 fail:
31026 return NULL;
31027 }
31028
31029
31030 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31031 PyObject *resultobj = 0;
31032 wxWindow *arg1 = (wxWindow *) 0 ;
31033 int *arg2 = (int *) 0 ;
31034 int *arg3 = (int *) 0 ;
31035 void *argp1 = 0 ;
31036 int res1 = 0 ;
31037 int temp2 ;
31038 int res2 = SWIG_TMPOBJ ;
31039 int temp3 ;
31040 int res3 = SWIG_TMPOBJ ;
31041 PyObject *swig_obj[1] ;
31042
31043 arg2 = &temp2;
31044 arg3 = &temp3;
31045 if (!args) SWIG_fail;
31046 swig_obj[0] = args;
31047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31048 if (!SWIG_IsOK(res1)) {
31049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31050 }
31051 arg1 = reinterpret_cast< wxWindow * >(argp1);
31052 {
31053 PyThreadState* __tstate = wxPyBeginAllowThreads();
31054 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31055 wxPyEndAllowThreads(__tstate);
31056 if (PyErr_Occurred()) SWIG_fail;
31057 }
31058 resultobj = SWIG_Py_Void();
31059 if (SWIG_IsTmpObj(res2)) {
31060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31061 } else {
31062 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31063 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31064 }
31065 if (SWIG_IsTmpObj(res3)) {
31066 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31067 } else {
31068 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31070 }
31071 return resultobj;
31072 fail:
31073 return NULL;
31074 }
31075
31076
31077 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31078 PyObject *resultobj = 0;
31079 wxWindow *arg1 = (wxWindow *) 0 ;
31080 wxPoint result;
31081 void *argp1 = 0 ;
31082 int res1 = 0 ;
31083 PyObject *swig_obj[1] ;
31084
31085 if (!args) SWIG_fail;
31086 swig_obj[0] = args;
31087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31088 if (!SWIG_IsOK(res1)) {
31089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31090 }
31091 arg1 = reinterpret_cast< wxWindow * >(argp1);
31092 {
31093 PyThreadState* __tstate = wxPyBeginAllowThreads();
31094 result = ((wxWindow const *)arg1)->GetScreenPosition();
31095 wxPyEndAllowThreads(__tstate);
31096 if (PyErr_Occurred()) SWIG_fail;
31097 }
31098 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31099 return resultobj;
31100 fail:
31101 return NULL;
31102 }
31103
31104
31105 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31106 PyObject *resultobj = 0;
31107 wxWindow *arg1 = (wxWindow *) 0 ;
31108 int *arg2 = (int *) 0 ;
31109 int *arg3 = (int *) 0 ;
31110 void *argp1 = 0 ;
31111 int res1 = 0 ;
31112 int temp2 ;
31113 int res2 = SWIG_TMPOBJ ;
31114 int temp3 ;
31115 int res3 = SWIG_TMPOBJ ;
31116 PyObject *swig_obj[1] ;
31117
31118 arg2 = &temp2;
31119 arg3 = &temp3;
31120 if (!args) SWIG_fail;
31121 swig_obj[0] = args;
31122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31123 if (!SWIG_IsOK(res1)) {
31124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31125 }
31126 arg1 = reinterpret_cast< wxWindow * >(argp1);
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_Py_Void();
31134 if (SWIG_IsTmpObj(res2)) {
31135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31136 } else {
31137 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31139 }
31140 if (SWIG_IsTmpObj(res3)) {
31141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31142 } else {
31143 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31145 }
31146 return resultobj;
31147 fail:
31148 return NULL;
31149 }
31150
31151
31152 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31153 PyObject *resultobj = 0;
31154 wxWindow *arg1 = (wxWindow *) 0 ;
31155 wxRect result;
31156 void *argp1 = 0 ;
31157 int res1 = 0 ;
31158 PyObject *swig_obj[1] ;
31159
31160 if (!args) SWIG_fail;
31161 swig_obj[0] = args;
31162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31163 if (!SWIG_IsOK(res1)) {
31164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31165 }
31166 arg1 = reinterpret_cast< wxWindow * >(argp1);
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 result = ((wxWindow const *)arg1)->GetScreenRect();
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31181 PyObject *resultobj = 0;
31182 wxWindow *arg1 = (wxWindow *) 0 ;
31183 wxSize result;
31184 void *argp1 = 0 ;
31185 int res1 = 0 ;
31186 PyObject *swig_obj[1] ;
31187
31188 if (!args) SWIG_fail;
31189 swig_obj[0] = args;
31190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31191 if (!SWIG_IsOK(res1)) {
31192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31193 }
31194 arg1 = reinterpret_cast< wxWindow * >(argp1);
31195 {
31196 PyThreadState* __tstate = wxPyBeginAllowThreads();
31197 result = ((wxWindow const *)arg1)->GetSize();
31198 wxPyEndAllowThreads(__tstate);
31199 if (PyErr_Occurred()) SWIG_fail;
31200 }
31201 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31202 return resultobj;
31203 fail:
31204 return NULL;
31205 }
31206
31207
31208 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31209 PyObject *resultobj = 0;
31210 wxWindow *arg1 = (wxWindow *) 0 ;
31211 int *arg2 = (int *) 0 ;
31212 int *arg3 = (int *) 0 ;
31213 void *argp1 = 0 ;
31214 int res1 = 0 ;
31215 int temp2 ;
31216 int res2 = SWIG_TMPOBJ ;
31217 int temp3 ;
31218 int res3 = SWIG_TMPOBJ ;
31219 PyObject *swig_obj[1] ;
31220
31221 arg2 = &temp2;
31222 arg3 = &temp3;
31223 if (!args) SWIG_fail;
31224 swig_obj[0] = args;
31225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31226 if (!SWIG_IsOK(res1)) {
31227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31228 }
31229 arg1 = reinterpret_cast< wxWindow * >(argp1);
31230 {
31231 PyThreadState* __tstate = wxPyBeginAllowThreads();
31232 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31233 wxPyEndAllowThreads(__tstate);
31234 if (PyErr_Occurred()) SWIG_fail;
31235 }
31236 resultobj = SWIG_Py_Void();
31237 if (SWIG_IsTmpObj(res2)) {
31238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31239 } else {
31240 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31242 }
31243 if (SWIG_IsTmpObj(res3)) {
31244 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31245 } else {
31246 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31248 }
31249 return resultobj;
31250 fail:
31251 return NULL;
31252 }
31253
31254
31255 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31256 PyObject *resultobj = 0;
31257 wxWindow *arg1 = (wxWindow *) 0 ;
31258 wxRect result;
31259 void *argp1 = 0 ;
31260 int res1 = 0 ;
31261 PyObject *swig_obj[1] ;
31262
31263 if (!args) SWIG_fail;
31264 swig_obj[0] = args;
31265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31266 if (!SWIG_IsOK(res1)) {
31267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31268 }
31269 arg1 = reinterpret_cast< wxWindow * >(argp1);
31270 {
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 result = ((wxWindow const *)arg1)->GetRect();
31273 wxPyEndAllowThreads(__tstate);
31274 if (PyErr_Occurred()) SWIG_fail;
31275 }
31276 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31277 return resultobj;
31278 fail:
31279 return NULL;
31280 }
31281
31282
31283 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31284 PyObject *resultobj = 0;
31285 wxWindow *arg1 = (wxWindow *) 0 ;
31286 wxSize result;
31287 void *argp1 = 0 ;
31288 int res1 = 0 ;
31289 PyObject *swig_obj[1] ;
31290
31291 if (!args) SWIG_fail;
31292 swig_obj[0] = args;
31293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31294 if (!SWIG_IsOK(res1)) {
31295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31296 }
31297 arg1 = reinterpret_cast< wxWindow * >(argp1);
31298 {
31299 PyThreadState* __tstate = wxPyBeginAllowThreads();
31300 result = ((wxWindow const *)arg1)->GetClientSize();
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31305 return resultobj;
31306 fail:
31307 return NULL;
31308 }
31309
31310
31311 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31312 PyObject *resultobj = 0;
31313 wxWindow *arg1 = (wxWindow *) 0 ;
31314 int *arg2 = (int *) 0 ;
31315 int *arg3 = (int *) 0 ;
31316 void *argp1 = 0 ;
31317 int res1 = 0 ;
31318 int temp2 ;
31319 int res2 = SWIG_TMPOBJ ;
31320 int temp3 ;
31321 int res3 = SWIG_TMPOBJ ;
31322 PyObject *swig_obj[1] ;
31323
31324 arg2 = &temp2;
31325 arg3 = &temp3;
31326 if (!args) SWIG_fail;
31327 swig_obj[0] = args;
31328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31329 if (!SWIG_IsOK(res1)) {
31330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31331 }
31332 arg1 = reinterpret_cast< wxWindow * >(argp1);
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 resultobj = SWIG_Py_Void();
31340 if (SWIG_IsTmpObj(res2)) {
31341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31342 } else {
31343 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31345 }
31346 if (SWIG_IsTmpObj(res3)) {
31347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31348 } else {
31349 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31351 }
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31359 PyObject *resultobj = 0;
31360 wxWindow *arg1 = (wxWindow *) 0 ;
31361 wxPoint result;
31362 void *argp1 = 0 ;
31363 int res1 = 0 ;
31364 PyObject *swig_obj[1] ;
31365
31366 if (!args) SWIG_fail;
31367 swig_obj[0] = args;
31368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31369 if (!SWIG_IsOK(res1)) {
31370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31371 }
31372 arg1 = reinterpret_cast< wxWindow * >(argp1);
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31376 wxPyEndAllowThreads(__tstate);
31377 if (PyErr_Occurred()) SWIG_fail;
31378 }
31379 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31387 PyObject *resultobj = 0;
31388 wxWindow *arg1 = (wxWindow *) 0 ;
31389 wxRect result;
31390 void *argp1 = 0 ;
31391 int res1 = 0 ;
31392 PyObject *swig_obj[1] ;
31393
31394 if (!args) SWIG_fail;
31395 swig_obj[0] = args;
31396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31397 if (!SWIG_IsOK(res1)) {
31398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31399 }
31400 arg1 = reinterpret_cast< wxWindow * >(argp1);
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 result = ((wxWindow const *)arg1)->GetClientRect();
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31408 return resultobj;
31409 fail:
31410 return NULL;
31411 }
31412
31413
31414 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31415 PyObject *resultobj = 0;
31416 wxWindow *arg1 = (wxWindow *) 0 ;
31417 wxSize result;
31418 void *argp1 = 0 ;
31419 int res1 = 0 ;
31420 PyObject *swig_obj[1] ;
31421
31422 if (!args) SWIG_fail;
31423 swig_obj[0] = args;
31424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31425 if (!SWIG_IsOK(res1)) {
31426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31427 }
31428 arg1 = reinterpret_cast< wxWindow * >(argp1);
31429 {
31430 PyThreadState* __tstate = wxPyBeginAllowThreads();
31431 result = ((wxWindow const *)arg1)->GetBestSize();
31432 wxPyEndAllowThreads(__tstate);
31433 if (PyErr_Occurred()) SWIG_fail;
31434 }
31435 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31436 return resultobj;
31437 fail:
31438 return NULL;
31439 }
31440
31441
31442 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 PyObject *resultobj = 0;
31444 wxWindow *arg1 = (wxWindow *) 0 ;
31445 int *arg2 = (int *) 0 ;
31446 int *arg3 = (int *) 0 ;
31447 void *argp1 = 0 ;
31448 int res1 = 0 ;
31449 int temp2 ;
31450 int res2 = SWIG_TMPOBJ ;
31451 int temp3 ;
31452 int res3 = SWIG_TMPOBJ ;
31453 PyObject *swig_obj[1] ;
31454
31455 arg2 = &temp2;
31456 arg3 = &temp3;
31457 if (!args) SWIG_fail;
31458 swig_obj[0] = args;
31459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31460 if (!SWIG_IsOK(res1)) {
31461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31462 }
31463 arg1 = reinterpret_cast< wxWindow * >(argp1);
31464 {
31465 PyThreadState* __tstate = wxPyBeginAllowThreads();
31466 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31467 wxPyEndAllowThreads(__tstate);
31468 if (PyErr_Occurred()) SWIG_fail;
31469 }
31470 resultobj = SWIG_Py_Void();
31471 if (SWIG_IsTmpObj(res2)) {
31472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31473 } else {
31474 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31476 }
31477 if (SWIG_IsTmpObj(res3)) {
31478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31479 } else {
31480 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31482 }
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31490 PyObject *resultobj = 0;
31491 wxWindow *arg1 = (wxWindow *) 0 ;
31492 void *argp1 = 0 ;
31493 int res1 = 0 ;
31494 PyObject *swig_obj[1] ;
31495
31496 if (!args) SWIG_fail;
31497 swig_obj[0] = args;
31498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31499 if (!SWIG_IsOK(res1)) {
31500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31501 }
31502 arg1 = reinterpret_cast< wxWindow * >(argp1);
31503 {
31504 PyThreadState* __tstate = wxPyBeginAllowThreads();
31505 (arg1)->InvalidateBestSize();
31506 wxPyEndAllowThreads(__tstate);
31507 if (PyErr_Occurred()) SWIG_fail;
31508 }
31509 resultobj = SWIG_Py_Void();
31510 return resultobj;
31511 fail:
31512 return NULL;
31513 }
31514
31515
31516 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31517 PyObject *resultobj = 0;
31518 wxWindow *arg1 = (wxWindow *) 0 ;
31519 wxSize *arg2 = 0 ;
31520 void *argp1 = 0 ;
31521 int res1 = 0 ;
31522 wxSize temp2 ;
31523 PyObject * obj0 = 0 ;
31524 PyObject * obj1 = 0 ;
31525 char * kwnames[] = {
31526 (char *) "self",(char *) "size", NULL
31527 };
31528
31529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31531 if (!SWIG_IsOK(res1)) {
31532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31533 }
31534 arg1 = reinterpret_cast< wxWindow * >(argp1);
31535 {
31536 arg2 = &temp2;
31537 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31538 }
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 resultobj = SWIG_Py_Void();
31546 return resultobj;
31547 fail:
31548 return NULL;
31549 }
31550
31551
31552 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31553 PyObject *resultobj = 0;
31554 wxWindow *arg1 = (wxWindow *) 0 ;
31555 wxSize result;
31556 void *argp1 = 0 ;
31557 int res1 = 0 ;
31558 PyObject *swig_obj[1] ;
31559
31560 if (!args) SWIG_fail;
31561 swig_obj[0] = args;
31562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31563 if (!SWIG_IsOK(res1)) {
31564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31565 }
31566 arg1 = reinterpret_cast< wxWindow * >(argp1);
31567 {
31568 PyThreadState* __tstate = wxPyBeginAllowThreads();
31569 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31570 wxPyEndAllowThreads(__tstate);
31571 if (PyErr_Occurred()) SWIG_fail;
31572 }
31573 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31574 return resultobj;
31575 fail:
31576 return NULL;
31577 }
31578
31579
31580 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31581 PyObject *resultobj = 0;
31582 wxWindow *arg1 = (wxWindow *) 0 ;
31583 wxSize result;
31584 void *argp1 = 0 ;
31585 int res1 = 0 ;
31586 PyObject *swig_obj[1] ;
31587
31588 if (!args) SWIG_fail;
31589 swig_obj[0] = args;
31590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31591 if (!SWIG_IsOK(res1)) {
31592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31593 }
31594 arg1 = reinterpret_cast< wxWindow * >(argp1);
31595 {
31596 PyThreadState* __tstate = wxPyBeginAllowThreads();
31597 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31598 wxPyEndAllowThreads(__tstate);
31599 if (PyErr_Occurred()) SWIG_fail;
31600 }
31601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31602 return resultobj;
31603 fail:
31604 return NULL;
31605 }
31606
31607
31608 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31609 PyObject *resultobj = 0;
31610 wxWindow *arg1 = (wxWindow *) 0 ;
31611 int arg2 = (int) wxBOTH ;
31612 void *argp1 = 0 ;
31613 int res1 = 0 ;
31614 int val2 ;
31615 int ecode2 = 0 ;
31616 PyObject * obj0 = 0 ;
31617 PyObject * obj1 = 0 ;
31618 char * kwnames[] = {
31619 (char *) "self",(char *) "direction", NULL
31620 };
31621
31622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31624 if (!SWIG_IsOK(res1)) {
31625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31626 }
31627 arg1 = reinterpret_cast< wxWindow * >(argp1);
31628 if (obj1) {
31629 ecode2 = SWIG_AsVal_int(obj1, &val2);
31630 if (!SWIG_IsOK(ecode2)) {
31631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31632 }
31633 arg2 = static_cast< int >(val2);
31634 }
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 (arg1)->Center(arg2);
31638 wxPyEndAllowThreads(__tstate);
31639 if (PyErr_Occurred()) SWIG_fail;
31640 }
31641 resultobj = SWIG_Py_Void();
31642 return resultobj;
31643 fail:
31644 return NULL;
31645 }
31646
31647
31648 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31649 PyObject *resultobj = 0;
31650 wxWindow *arg1 = (wxWindow *) 0 ;
31651 int arg2 = (int) wxBOTH ;
31652 void *argp1 = 0 ;
31653 int res1 = 0 ;
31654 int val2 ;
31655 int ecode2 = 0 ;
31656 PyObject * obj0 = 0 ;
31657 PyObject * obj1 = 0 ;
31658 char * kwnames[] = {
31659 (char *) "self",(char *) "dir", NULL
31660 };
31661
31662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31664 if (!SWIG_IsOK(res1)) {
31665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31666 }
31667 arg1 = reinterpret_cast< wxWindow * >(argp1);
31668 if (obj1) {
31669 ecode2 = SWIG_AsVal_int(obj1, &val2);
31670 if (!SWIG_IsOK(ecode2)) {
31671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31672 }
31673 arg2 = static_cast< int >(val2);
31674 }
31675 {
31676 PyThreadState* __tstate = wxPyBeginAllowThreads();
31677 (arg1)->CenterOnParent(arg2);
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 resultobj = SWIG_Py_Void();
31682 return resultobj;
31683 fail:
31684 return NULL;
31685 }
31686
31687
31688 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31689 PyObject *resultobj = 0;
31690 wxWindow *arg1 = (wxWindow *) 0 ;
31691 void *argp1 = 0 ;
31692 int res1 = 0 ;
31693 PyObject *swig_obj[1] ;
31694
31695 if (!args) SWIG_fail;
31696 swig_obj[0] = args;
31697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31698 if (!SWIG_IsOK(res1)) {
31699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31700 }
31701 arg1 = reinterpret_cast< wxWindow * >(argp1);
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 (arg1)->Fit();
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_Py_Void();
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31716 PyObject *resultobj = 0;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 void *argp1 = 0 ;
31719 int res1 = 0 ;
31720 PyObject *swig_obj[1] ;
31721
31722 if (!args) SWIG_fail;
31723 swig_obj[0] = args;
31724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31725 if (!SWIG_IsOK(res1)) {
31726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31727 }
31728 arg1 = reinterpret_cast< wxWindow * >(argp1);
31729 {
31730 PyThreadState* __tstate = wxPyBeginAllowThreads();
31731 (arg1)->FitInside();
31732 wxPyEndAllowThreads(__tstate);
31733 if (PyErr_Occurred()) SWIG_fail;
31734 }
31735 resultobj = SWIG_Py_Void();
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31743 PyObject *resultobj = 0;
31744 wxWindow *arg1 = (wxWindow *) 0 ;
31745 int arg2 ;
31746 int arg3 ;
31747 int arg4 = (int) -1 ;
31748 int arg5 = (int) -1 ;
31749 int arg6 = (int) -1 ;
31750 int arg7 = (int) -1 ;
31751 void *argp1 = 0 ;
31752 int res1 = 0 ;
31753 int val2 ;
31754 int ecode2 = 0 ;
31755 int val3 ;
31756 int ecode3 = 0 ;
31757 int val4 ;
31758 int ecode4 = 0 ;
31759 int val5 ;
31760 int ecode5 = 0 ;
31761 int val6 ;
31762 int ecode6 = 0 ;
31763 int val7 ;
31764 int ecode7 = 0 ;
31765 PyObject * obj0 = 0 ;
31766 PyObject * obj1 = 0 ;
31767 PyObject * obj2 = 0 ;
31768 PyObject * obj3 = 0 ;
31769 PyObject * obj4 = 0 ;
31770 PyObject * obj5 = 0 ;
31771 PyObject * obj6 = 0 ;
31772 char * kwnames[] = {
31773 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31774 };
31775
31776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31778 if (!SWIG_IsOK(res1)) {
31779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31780 }
31781 arg1 = reinterpret_cast< wxWindow * >(argp1);
31782 ecode2 = SWIG_AsVal_int(obj1, &val2);
31783 if (!SWIG_IsOK(ecode2)) {
31784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31785 }
31786 arg2 = static_cast< int >(val2);
31787 ecode3 = SWIG_AsVal_int(obj2, &val3);
31788 if (!SWIG_IsOK(ecode3)) {
31789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31790 }
31791 arg3 = static_cast< int >(val3);
31792 if (obj3) {
31793 ecode4 = SWIG_AsVal_int(obj3, &val4);
31794 if (!SWIG_IsOK(ecode4)) {
31795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31796 }
31797 arg4 = static_cast< int >(val4);
31798 }
31799 if (obj4) {
31800 ecode5 = SWIG_AsVal_int(obj4, &val5);
31801 if (!SWIG_IsOK(ecode5)) {
31802 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31803 }
31804 arg5 = static_cast< int >(val5);
31805 }
31806 if (obj5) {
31807 ecode6 = SWIG_AsVal_int(obj5, &val6);
31808 if (!SWIG_IsOK(ecode6)) {
31809 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31810 }
31811 arg6 = static_cast< int >(val6);
31812 }
31813 if (obj6) {
31814 ecode7 = SWIG_AsVal_int(obj6, &val7);
31815 if (!SWIG_IsOK(ecode7)) {
31816 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31817 }
31818 arg7 = static_cast< int >(val7);
31819 }
31820 {
31821 PyThreadState* __tstate = wxPyBeginAllowThreads();
31822 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31823 wxPyEndAllowThreads(__tstate);
31824 if (PyErr_Occurred()) SWIG_fail;
31825 }
31826 resultobj = SWIG_Py_Void();
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31834 PyObject *resultobj = 0;
31835 wxWindow *arg1 = (wxWindow *) 0 ;
31836 wxSize *arg2 = 0 ;
31837 wxSize const &arg3_defvalue = wxDefaultSize ;
31838 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31839 wxSize const &arg4_defvalue = wxDefaultSize ;
31840 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31841 void *argp1 = 0 ;
31842 int res1 = 0 ;
31843 wxSize temp2 ;
31844 wxSize temp3 ;
31845 wxSize temp4 ;
31846 PyObject * obj0 = 0 ;
31847 PyObject * obj1 = 0 ;
31848 PyObject * obj2 = 0 ;
31849 PyObject * obj3 = 0 ;
31850 char * kwnames[] = {
31851 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31852 };
31853
31854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31856 if (!SWIG_IsOK(res1)) {
31857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31858 }
31859 arg1 = reinterpret_cast< wxWindow * >(argp1);
31860 {
31861 arg2 = &temp2;
31862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31863 }
31864 if (obj2) {
31865 {
31866 arg3 = &temp3;
31867 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31868 }
31869 }
31870 if (obj3) {
31871 {
31872 arg4 = &temp4;
31873 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31874 }
31875 }
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 resultobj = SWIG_Py_Void();
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj = 0;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 int arg2 ;
31893 int arg3 ;
31894 int arg4 = (int) -1 ;
31895 int arg5 = (int) -1 ;
31896 void *argp1 = 0 ;
31897 int res1 = 0 ;
31898 int val2 ;
31899 int ecode2 = 0 ;
31900 int val3 ;
31901 int ecode3 = 0 ;
31902 int val4 ;
31903 int ecode4 = 0 ;
31904 int val5 ;
31905 int ecode5 = 0 ;
31906 PyObject * obj0 = 0 ;
31907 PyObject * obj1 = 0 ;
31908 PyObject * obj2 = 0 ;
31909 PyObject * obj3 = 0 ;
31910 PyObject * obj4 = 0 ;
31911 char * kwnames[] = {
31912 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31913 };
31914
31915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31919 }
31920 arg1 = reinterpret_cast< wxWindow * >(argp1);
31921 ecode2 = SWIG_AsVal_int(obj1, &val2);
31922 if (!SWIG_IsOK(ecode2)) {
31923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31924 }
31925 arg2 = static_cast< int >(val2);
31926 ecode3 = SWIG_AsVal_int(obj2, &val3);
31927 if (!SWIG_IsOK(ecode3)) {
31928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31929 }
31930 arg3 = static_cast< int >(val3);
31931 if (obj3) {
31932 ecode4 = SWIG_AsVal_int(obj3, &val4);
31933 if (!SWIG_IsOK(ecode4)) {
31934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31935 }
31936 arg4 = static_cast< int >(val4);
31937 }
31938 if (obj4) {
31939 ecode5 = SWIG_AsVal_int(obj4, &val5);
31940 if (!SWIG_IsOK(ecode5)) {
31941 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31942 }
31943 arg5 = static_cast< int >(val5);
31944 }
31945 {
31946 PyThreadState* __tstate = wxPyBeginAllowThreads();
31947 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31948 wxPyEndAllowThreads(__tstate);
31949 if (PyErr_Occurred()) SWIG_fail;
31950 }
31951 resultobj = SWIG_Py_Void();
31952 return resultobj;
31953 fail:
31954 return NULL;
31955 }
31956
31957
31958 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31959 PyObject *resultobj = 0;
31960 wxWindow *arg1 = (wxWindow *) 0 ;
31961 wxSize *arg2 = 0 ;
31962 wxSize const &arg3_defvalue = wxDefaultSize ;
31963 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31964 void *argp1 = 0 ;
31965 int res1 = 0 ;
31966 wxSize temp2 ;
31967 wxSize temp3 ;
31968 PyObject * obj0 = 0 ;
31969 PyObject * obj1 = 0 ;
31970 PyObject * obj2 = 0 ;
31971 char * kwnames[] = {
31972 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31973 };
31974
31975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31977 if (!SWIG_IsOK(res1)) {
31978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31979 }
31980 arg1 = reinterpret_cast< wxWindow * >(argp1);
31981 {
31982 arg2 = &temp2;
31983 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31984 }
31985 if (obj2) {
31986 {
31987 arg3 = &temp3;
31988 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31989 }
31990 }
31991 {
31992 PyThreadState* __tstate = wxPyBeginAllowThreads();
31993 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31994 wxPyEndAllowThreads(__tstate);
31995 if (PyErr_Occurred()) SWIG_fail;
31996 }
31997 resultobj = SWIG_Py_Void();
31998 return resultobj;
31999 fail:
32000 return NULL;
32001 }
32002
32003
32004 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32005 PyObject *resultobj = 0;
32006 wxWindow *arg1 = (wxWindow *) 0 ;
32007 wxSize result;
32008 void *argp1 = 0 ;
32009 int res1 = 0 ;
32010 PyObject *swig_obj[1] ;
32011
32012 if (!args) SWIG_fail;
32013 swig_obj[0] = args;
32014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32015 if (!SWIG_IsOK(res1)) {
32016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32017 }
32018 arg1 = reinterpret_cast< wxWindow * >(argp1);
32019 {
32020 PyThreadState* __tstate = wxPyBeginAllowThreads();
32021 result = ((wxWindow const *)arg1)->GetMaxSize();
32022 wxPyEndAllowThreads(__tstate);
32023 if (PyErr_Occurred()) SWIG_fail;
32024 }
32025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32026 return resultobj;
32027 fail:
32028 return NULL;
32029 }
32030
32031
32032 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32033 PyObject *resultobj = 0;
32034 wxWindow *arg1 = (wxWindow *) 0 ;
32035 wxSize result;
32036 void *argp1 = 0 ;
32037 int res1 = 0 ;
32038 PyObject *swig_obj[1] ;
32039
32040 if (!args) SWIG_fail;
32041 swig_obj[0] = args;
32042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32043 if (!SWIG_IsOK(res1)) {
32044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32045 }
32046 arg1 = reinterpret_cast< wxWindow * >(argp1);
32047 {
32048 PyThreadState* __tstate = wxPyBeginAllowThreads();
32049 result = ((wxWindow const *)arg1)->GetMinSize();
32050 wxPyEndAllowThreads(__tstate);
32051 if (PyErr_Occurred()) SWIG_fail;
32052 }
32053 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32054 return resultobj;
32055 fail:
32056 return NULL;
32057 }
32058
32059
32060 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32061 PyObject *resultobj = 0;
32062 wxWindow *arg1 = (wxWindow *) 0 ;
32063 wxSize *arg2 = 0 ;
32064 void *argp1 = 0 ;
32065 int res1 = 0 ;
32066 wxSize temp2 ;
32067 PyObject * obj0 = 0 ;
32068 PyObject * obj1 = 0 ;
32069 char * kwnames[] = {
32070 (char *) "self",(char *) "minSize", NULL
32071 };
32072
32073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32075 if (!SWIG_IsOK(res1)) {
32076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32077 }
32078 arg1 = reinterpret_cast< wxWindow * >(argp1);
32079 {
32080 arg2 = &temp2;
32081 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32082 }
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 (arg1)->SetMinSize((wxSize const &)*arg2);
32086 wxPyEndAllowThreads(__tstate);
32087 if (PyErr_Occurred()) SWIG_fail;
32088 }
32089 resultobj = SWIG_Py_Void();
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32097 PyObject *resultobj = 0;
32098 wxWindow *arg1 = (wxWindow *) 0 ;
32099 wxSize *arg2 = 0 ;
32100 void *argp1 = 0 ;
32101 int res1 = 0 ;
32102 wxSize temp2 ;
32103 PyObject * obj0 = 0 ;
32104 PyObject * obj1 = 0 ;
32105 char * kwnames[] = {
32106 (char *) "self",(char *) "maxSize", NULL
32107 };
32108
32109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32111 if (!SWIG_IsOK(res1)) {
32112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32113 }
32114 arg1 = reinterpret_cast< wxWindow * >(argp1);
32115 {
32116 arg2 = &temp2;
32117 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32118 }
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 (arg1)->SetMaxSize((wxSize const &)*arg2);
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_Py_Void();
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 wxWindow *arg1 = (wxWindow *) 0 ;
32135 int result;
32136 void *argp1 = 0 ;
32137 int res1 = 0 ;
32138 PyObject *swig_obj[1] ;
32139
32140 if (!args) SWIG_fail;
32141 swig_obj[0] = args;
32142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32145 }
32146 arg1 = reinterpret_cast< wxWindow * >(argp1);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_From_int(static_cast< int >(result));
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxWindow *arg1 = (wxWindow *) 0 ;
32163 int result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 PyObject *swig_obj[1] ;
32167
32168 if (!args) SWIG_fail;
32169 swig_obj[0] = args;
32170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32171 if (!SWIG_IsOK(res1)) {
32172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32173 }
32174 arg1 = reinterpret_cast< wxWindow * >(argp1);
32175 {
32176 PyThreadState* __tstate = wxPyBeginAllowThreads();
32177 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 resultobj = SWIG_From_int(static_cast< int >(result));
32182 return resultobj;
32183 fail:
32184 return NULL;
32185 }
32186
32187
32188 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32189 PyObject *resultobj = 0;
32190 wxWindow *arg1 = (wxWindow *) 0 ;
32191 int result;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 PyObject *swig_obj[1] ;
32195
32196 if (!args) SWIG_fail;
32197 swig_obj[0] = args;
32198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32199 if (!SWIG_IsOK(res1)) {
32200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32201 }
32202 arg1 = reinterpret_cast< wxWindow * >(argp1);
32203 {
32204 PyThreadState* __tstate = wxPyBeginAllowThreads();
32205 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32206 wxPyEndAllowThreads(__tstate);
32207 if (PyErr_Occurred()) SWIG_fail;
32208 }
32209 resultobj = SWIG_From_int(static_cast< int >(result));
32210 return resultobj;
32211 fail:
32212 return NULL;
32213 }
32214
32215
32216 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32217 PyObject *resultobj = 0;
32218 wxWindow *arg1 = (wxWindow *) 0 ;
32219 int result;
32220 void *argp1 = 0 ;
32221 int res1 = 0 ;
32222 PyObject *swig_obj[1] ;
32223
32224 if (!args) SWIG_fail;
32225 swig_obj[0] = args;
32226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32227 if (!SWIG_IsOK(res1)) {
32228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32229 }
32230 arg1 = reinterpret_cast< wxWindow * >(argp1);
32231 {
32232 PyThreadState* __tstate = wxPyBeginAllowThreads();
32233 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32234 wxPyEndAllowThreads(__tstate);
32235 if (PyErr_Occurred()) SWIG_fail;
32236 }
32237 resultobj = SWIG_From_int(static_cast< int >(result));
32238 return resultobj;
32239 fail:
32240 return NULL;
32241 }
32242
32243
32244 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32245 PyObject *resultobj = 0;
32246 wxWindow *arg1 = (wxWindow *) 0 ;
32247 wxSize *arg2 = 0 ;
32248 void *argp1 = 0 ;
32249 int res1 = 0 ;
32250 wxSize temp2 ;
32251 PyObject * obj0 = 0 ;
32252 PyObject * obj1 = 0 ;
32253 char * kwnames[] = {
32254 (char *) "self",(char *) "size", NULL
32255 };
32256
32257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32259 if (!SWIG_IsOK(res1)) {
32260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32261 }
32262 arg1 = reinterpret_cast< wxWindow * >(argp1);
32263 {
32264 arg2 = &temp2;
32265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32266 }
32267 {
32268 PyThreadState* __tstate = wxPyBeginAllowThreads();
32269 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32270 wxPyEndAllowThreads(__tstate);
32271 if (PyErr_Occurred()) SWIG_fail;
32272 }
32273 resultobj = SWIG_Py_Void();
32274 return resultobj;
32275 fail:
32276 return NULL;
32277 }
32278
32279
32280 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32281 PyObject *resultobj = 0;
32282 wxWindow *arg1 = (wxWindow *) 0 ;
32283 int arg2 ;
32284 int arg3 ;
32285 void *argp1 = 0 ;
32286 int res1 = 0 ;
32287 int val2 ;
32288 int ecode2 = 0 ;
32289 int val3 ;
32290 int ecode3 = 0 ;
32291 PyObject * obj0 = 0 ;
32292 PyObject * obj1 = 0 ;
32293 PyObject * obj2 = 0 ;
32294 char * kwnames[] = {
32295 (char *) "self",(char *) "w",(char *) "h", NULL
32296 };
32297
32298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32300 if (!SWIG_IsOK(res1)) {
32301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32302 }
32303 arg1 = reinterpret_cast< wxWindow * >(argp1);
32304 ecode2 = SWIG_AsVal_int(obj1, &val2);
32305 if (!SWIG_IsOK(ecode2)) {
32306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32307 }
32308 arg2 = static_cast< int >(val2);
32309 ecode3 = SWIG_AsVal_int(obj2, &val3);
32310 if (!SWIG_IsOK(ecode3)) {
32311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32312 }
32313 arg3 = static_cast< int >(val3);
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 (arg1)->SetVirtualSize(arg2,arg3);
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 resultobj = SWIG_Py_Void();
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32328 PyObject *resultobj = 0;
32329 wxWindow *arg1 = (wxWindow *) 0 ;
32330 wxSize result;
32331 void *argp1 = 0 ;
32332 int res1 = 0 ;
32333 PyObject *swig_obj[1] ;
32334
32335 if (!args) SWIG_fail;
32336 swig_obj[0] = args;
32337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32338 if (!SWIG_IsOK(res1)) {
32339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32340 }
32341 arg1 = reinterpret_cast< wxWindow * >(argp1);
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 result = ((wxWindow const *)arg1)->GetVirtualSize();
32345 wxPyEndAllowThreads(__tstate);
32346 if (PyErr_Occurred()) SWIG_fail;
32347 }
32348 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32349 return resultobj;
32350 fail:
32351 return NULL;
32352 }
32353
32354
32355 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32356 PyObject *resultobj = 0;
32357 wxWindow *arg1 = (wxWindow *) 0 ;
32358 int *arg2 = (int *) 0 ;
32359 int *arg3 = (int *) 0 ;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 int temp2 ;
32363 int res2 = SWIG_TMPOBJ ;
32364 int temp3 ;
32365 int res3 = SWIG_TMPOBJ ;
32366 PyObject *swig_obj[1] ;
32367
32368 arg2 = &temp2;
32369 arg3 = &temp3;
32370 if (!args) SWIG_fail;
32371 swig_obj[0] = args;
32372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32373 if (!SWIG_IsOK(res1)) {
32374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32375 }
32376 arg1 = reinterpret_cast< wxWindow * >(argp1);
32377 {
32378 PyThreadState* __tstate = wxPyBeginAllowThreads();
32379 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32380 wxPyEndAllowThreads(__tstate);
32381 if (PyErr_Occurred()) SWIG_fail;
32382 }
32383 resultobj = SWIG_Py_Void();
32384 if (SWIG_IsTmpObj(res2)) {
32385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32386 } else {
32387 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32389 }
32390 if (SWIG_IsTmpObj(res3)) {
32391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32392 } else {
32393 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32395 }
32396 return resultobj;
32397 fail:
32398 return NULL;
32399 }
32400
32401
32402 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32403 PyObject *resultobj = 0;
32404 wxWindow *arg1 = (wxWindow *) 0 ;
32405 wxSize result;
32406 void *argp1 = 0 ;
32407 int res1 = 0 ;
32408 PyObject *swig_obj[1] ;
32409
32410 if (!args) SWIG_fail;
32411 swig_obj[0] = args;
32412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32413 if (!SWIG_IsOK(res1)) {
32414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32415 }
32416 arg1 = reinterpret_cast< wxWindow * >(argp1);
32417 {
32418 PyThreadState* __tstate = wxPyBeginAllowThreads();
32419 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj = 0;
32432 wxWindow *arg1 = (wxWindow *) 0 ;
32433 bool arg2 = (bool) true ;
32434 bool result;
32435 void *argp1 = 0 ;
32436 int res1 = 0 ;
32437 bool val2 ;
32438 int ecode2 = 0 ;
32439 PyObject * obj0 = 0 ;
32440 PyObject * obj1 = 0 ;
32441 char * kwnames[] = {
32442 (char *) "self",(char *) "show", NULL
32443 };
32444
32445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32447 if (!SWIG_IsOK(res1)) {
32448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32449 }
32450 arg1 = reinterpret_cast< wxWindow * >(argp1);
32451 if (obj1) {
32452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32453 if (!SWIG_IsOK(ecode2)) {
32454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32455 }
32456 arg2 = static_cast< bool >(val2);
32457 }
32458 {
32459 PyThreadState* __tstate = wxPyBeginAllowThreads();
32460 result = (bool)(arg1)->Show(arg2);
32461 wxPyEndAllowThreads(__tstate);
32462 if (PyErr_Occurred()) SWIG_fail;
32463 }
32464 {
32465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32466 }
32467 return resultobj;
32468 fail:
32469 return NULL;
32470 }
32471
32472
32473 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32474 PyObject *resultobj = 0;
32475 wxWindow *arg1 = (wxWindow *) 0 ;
32476 bool result;
32477 void *argp1 = 0 ;
32478 int res1 = 0 ;
32479 PyObject *swig_obj[1] ;
32480
32481 if (!args) SWIG_fail;
32482 swig_obj[0] = args;
32483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32484 if (!SWIG_IsOK(res1)) {
32485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32486 }
32487 arg1 = reinterpret_cast< wxWindow * >(argp1);
32488 {
32489 PyThreadState* __tstate = wxPyBeginAllowThreads();
32490 result = (bool)(arg1)->Hide();
32491 wxPyEndAllowThreads(__tstate);
32492 if (PyErr_Occurred()) SWIG_fail;
32493 }
32494 {
32495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32496 }
32497 return resultobj;
32498 fail:
32499 return NULL;
32500 }
32501
32502
32503 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32504 PyObject *resultobj = 0;
32505 wxWindow *arg1 = (wxWindow *) 0 ;
32506 bool arg2 = (bool) true ;
32507 bool result;
32508 void *argp1 = 0 ;
32509 int res1 = 0 ;
32510 bool val2 ;
32511 int ecode2 = 0 ;
32512 PyObject * obj0 = 0 ;
32513 PyObject * obj1 = 0 ;
32514 char * kwnames[] = {
32515 (char *) "self",(char *) "enable", NULL
32516 };
32517
32518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32520 if (!SWIG_IsOK(res1)) {
32521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32522 }
32523 arg1 = reinterpret_cast< wxWindow * >(argp1);
32524 if (obj1) {
32525 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32526 if (!SWIG_IsOK(ecode2)) {
32527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32528 }
32529 arg2 = static_cast< bool >(val2);
32530 }
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = (bool)(arg1)->Enable(arg2);
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 {
32538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32539 }
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxWindow *arg1 = (wxWindow *) 0 ;
32549 bool result;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32559 }
32560 arg1 = reinterpret_cast< wxWindow * >(argp1);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 result = (bool)(arg1)->Disable();
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 {
32568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32569 }
32570 return resultobj;
32571 fail:
32572 return NULL;
32573 }
32574
32575
32576 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32577 PyObject *resultobj = 0;
32578 wxWindow *arg1 = (wxWindow *) 0 ;
32579 bool result;
32580 void *argp1 = 0 ;
32581 int res1 = 0 ;
32582 PyObject *swig_obj[1] ;
32583
32584 if (!args) SWIG_fail;
32585 swig_obj[0] = args;
32586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32587 if (!SWIG_IsOK(res1)) {
32588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32589 }
32590 arg1 = reinterpret_cast< wxWindow * >(argp1);
32591 {
32592 PyThreadState* __tstate = wxPyBeginAllowThreads();
32593 result = (bool)((wxWindow const *)arg1)->IsShown();
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 {
32598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32599 }
32600 return resultobj;
32601 fail:
32602 return NULL;
32603 }
32604
32605
32606 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32607 PyObject *resultobj = 0;
32608 wxWindow *arg1 = (wxWindow *) 0 ;
32609 bool result;
32610 void *argp1 = 0 ;
32611 int res1 = 0 ;
32612 PyObject *swig_obj[1] ;
32613
32614 if (!args) SWIG_fail;
32615 swig_obj[0] = args;
32616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32619 }
32620 arg1 = reinterpret_cast< wxWindow * >(argp1);
32621 {
32622 PyThreadState* __tstate = wxPyBeginAllowThreads();
32623 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32624 wxPyEndAllowThreads(__tstate);
32625 if (PyErr_Occurred()) SWIG_fail;
32626 }
32627 {
32628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32629 }
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32637 PyObject *resultobj = 0;
32638 wxWindow *arg1 = (wxWindow *) 0 ;
32639 long arg2 ;
32640 void *argp1 = 0 ;
32641 int res1 = 0 ;
32642 long val2 ;
32643 int ecode2 = 0 ;
32644 PyObject * obj0 = 0 ;
32645 PyObject * obj1 = 0 ;
32646 char * kwnames[] = {
32647 (char *) "self",(char *) "style", NULL
32648 };
32649
32650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32652 if (!SWIG_IsOK(res1)) {
32653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32654 }
32655 arg1 = reinterpret_cast< wxWindow * >(argp1);
32656 ecode2 = SWIG_AsVal_long(obj1, &val2);
32657 if (!SWIG_IsOK(ecode2)) {
32658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32659 }
32660 arg2 = static_cast< long >(val2);
32661 {
32662 PyThreadState* __tstate = wxPyBeginAllowThreads();
32663 (arg1)->SetWindowStyleFlag(arg2);
32664 wxPyEndAllowThreads(__tstate);
32665 if (PyErr_Occurred()) SWIG_fail;
32666 }
32667 resultobj = SWIG_Py_Void();
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32675 PyObject *resultobj = 0;
32676 wxWindow *arg1 = (wxWindow *) 0 ;
32677 long result;
32678 void *argp1 = 0 ;
32679 int res1 = 0 ;
32680 PyObject *swig_obj[1] ;
32681
32682 if (!args) SWIG_fail;
32683 swig_obj[0] = args;
32684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32685 if (!SWIG_IsOK(res1)) {
32686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32687 }
32688 arg1 = reinterpret_cast< wxWindow * >(argp1);
32689 {
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32692 wxPyEndAllowThreads(__tstate);
32693 if (PyErr_Occurred()) SWIG_fail;
32694 }
32695 resultobj = SWIG_From_long(static_cast< long >(result));
32696 return resultobj;
32697 fail:
32698 return NULL;
32699 }
32700
32701
32702 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32703 PyObject *resultobj = 0;
32704 wxWindow *arg1 = (wxWindow *) 0 ;
32705 int arg2 ;
32706 bool result;
32707 void *argp1 = 0 ;
32708 int res1 = 0 ;
32709 int val2 ;
32710 int ecode2 = 0 ;
32711 PyObject * obj0 = 0 ;
32712 PyObject * obj1 = 0 ;
32713 char * kwnames[] = {
32714 (char *) "self",(char *) "flag", NULL
32715 };
32716
32717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32719 if (!SWIG_IsOK(res1)) {
32720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32721 }
32722 arg1 = reinterpret_cast< wxWindow * >(argp1);
32723 ecode2 = SWIG_AsVal_int(obj1, &val2);
32724 if (!SWIG_IsOK(ecode2)) {
32725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32726 }
32727 arg2 = static_cast< int >(val2);
32728 {
32729 PyThreadState* __tstate = wxPyBeginAllowThreads();
32730 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32731 wxPyEndAllowThreads(__tstate);
32732 if (PyErr_Occurred()) SWIG_fail;
32733 }
32734 {
32735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32736 }
32737 return resultobj;
32738 fail:
32739 return NULL;
32740 }
32741
32742
32743 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32744 PyObject *resultobj = 0;
32745 wxWindow *arg1 = (wxWindow *) 0 ;
32746 bool result;
32747 void *argp1 = 0 ;
32748 int res1 = 0 ;
32749 PyObject *swig_obj[1] ;
32750
32751 if (!args) SWIG_fail;
32752 swig_obj[0] = args;
32753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32754 if (!SWIG_IsOK(res1)) {
32755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32756 }
32757 arg1 = reinterpret_cast< wxWindow * >(argp1);
32758 {
32759 PyThreadState* __tstate = wxPyBeginAllowThreads();
32760 result = (bool)((wxWindow const *)arg1)->IsRetained();
32761 wxPyEndAllowThreads(__tstate);
32762 if (PyErr_Occurred()) SWIG_fail;
32763 }
32764 {
32765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32766 }
32767 return resultobj;
32768 fail:
32769 return NULL;
32770 }
32771
32772
32773 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32774 PyObject *resultobj = 0;
32775 wxWindow *arg1 = (wxWindow *) 0 ;
32776 long arg2 ;
32777 void *argp1 = 0 ;
32778 int res1 = 0 ;
32779 long val2 ;
32780 int ecode2 = 0 ;
32781 PyObject * obj0 = 0 ;
32782 PyObject * obj1 = 0 ;
32783 char * kwnames[] = {
32784 (char *) "self",(char *) "exStyle", NULL
32785 };
32786
32787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32789 if (!SWIG_IsOK(res1)) {
32790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32791 }
32792 arg1 = reinterpret_cast< wxWindow * >(argp1);
32793 ecode2 = SWIG_AsVal_long(obj1, &val2);
32794 if (!SWIG_IsOK(ecode2)) {
32795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32796 }
32797 arg2 = static_cast< long >(val2);
32798 {
32799 PyThreadState* __tstate = wxPyBeginAllowThreads();
32800 (arg1)->SetExtraStyle(arg2);
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 resultobj = SWIG_Py_Void();
32805 return resultobj;
32806 fail:
32807 return NULL;
32808 }
32809
32810
32811 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32812 PyObject *resultobj = 0;
32813 wxWindow *arg1 = (wxWindow *) 0 ;
32814 long result;
32815 void *argp1 = 0 ;
32816 int res1 = 0 ;
32817 PyObject *swig_obj[1] ;
32818
32819 if (!args) SWIG_fail;
32820 swig_obj[0] = args;
32821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32822 if (!SWIG_IsOK(res1)) {
32823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32824 }
32825 arg1 = reinterpret_cast< wxWindow * >(argp1);
32826 {
32827 PyThreadState* __tstate = wxPyBeginAllowThreads();
32828 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32829 wxPyEndAllowThreads(__tstate);
32830 if (PyErr_Occurred()) SWIG_fail;
32831 }
32832 resultobj = SWIG_From_long(static_cast< long >(result));
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32840 PyObject *resultobj = 0;
32841 wxWindow *arg1 = (wxWindow *) 0 ;
32842 bool arg2 = (bool) true ;
32843 void *argp1 = 0 ;
32844 int res1 = 0 ;
32845 bool val2 ;
32846 int ecode2 = 0 ;
32847 PyObject * obj0 = 0 ;
32848 PyObject * obj1 = 0 ;
32849 char * kwnames[] = {
32850 (char *) "self",(char *) "modal", NULL
32851 };
32852
32853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32855 if (!SWIG_IsOK(res1)) {
32856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32857 }
32858 arg1 = reinterpret_cast< wxWindow * >(argp1);
32859 if (obj1) {
32860 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32861 if (!SWIG_IsOK(ecode2)) {
32862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32863 }
32864 arg2 = static_cast< bool >(val2);
32865 }
32866 {
32867 PyThreadState* __tstate = wxPyBeginAllowThreads();
32868 (arg1)->MakeModal(arg2);
32869 wxPyEndAllowThreads(__tstate);
32870 if (PyErr_Occurred()) SWIG_fail;
32871 }
32872 resultobj = SWIG_Py_Void();
32873 return resultobj;
32874 fail:
32875 return NULL;
32876 }
32877
32878
32879 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32880 PyObject *resultobj = 0;
32881 wxWindow *arg1 = (wxWindow *) 0 ;
32882 bool arg2 ;
32883 void *argp1 = 0 ;
32884 int res1 = 0 ;
32885 bool val2 ;
32886 int ecode2 = 0 ;
32887 PyObject * obj0 = 0 ;
32888 PyObject * obj1 = 0 ;
32889 char * kwnames[] = {
32890 (char *) "self",(char *) "enableTheme", NULL
32891 };
32892
32893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32895 if (!SWIG_IsOK(res1)) {
32896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32897 }
32898 arg1 = reinterpret_cast< wxWindow * >(argp1);
32899 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32900 if (!SWIG_IsOK(ecode2)) {
32901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32902 }
32903 arg2 = static_cast< bool >(val2);
32904 {
32905 PyThreadState* __tstate = wxPyBeginAllowThreads();
32906 (arg1)->SetThemeEnabled(arg2);
32907 wxPyEndAllowThreads(__tstate);
32908 if (PyErr_Occurred()) SWIG_fail;
32909 }
32910 resultobj = SWIG_Py_Void();
32911 return resultobj;
32912 fail:
32913 return NULL;
32914 }
32915
32916
32917 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32918 PyObject *resultobj = 0;
32919 wxWindow *arg1 = (wxWindow *) 0 ;
32920 bool result;
32921 void *argp1 = 0 ;
32922 int res1 = 0 ;
32923 PyObject *swig_obj[1] ;
32924
32925 if (!args) SWIG_fail;
32926 swig_obj[0] = args;
32927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32928 if (!SWIG_IsOK(res1)) {
32929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32930 }
32931 arg1 = reinterpret_cast< wxWindow * >(argp1);
32932 {
32933 PyThreadState* __tstate = wxPyBeginAllowThreads();
32934 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32935 wxPyEndAllowThreads(__tstate);
32936 if (PyErr_Occurred()) SWIG_fail;
32937 }
32938 {
32939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32940 }
32941 return resultobj;
32942 fail:
32943 return NULL;
32944 }
32945
32946
32947 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32948 PyObject *resultobj = 0;
32949 wxWindow *arg1 = (wxWindow *) 0 ;
32950 void *argp1 = 0 ;
32951 int res1 = 0 ;
32952 PyObject *swig_obj[1] ;
32953
32954 if (!args) SWIG_fail;
32955 swig_obj[0] = args;
32956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32957 if (!SWIG_IsOK(res1)) {
32958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32959 }
32960 arg1 = reinterpret_cast< wxWindow * >(argp1);
32961 {
32962 PyThreadState* __tstate = wxPyBeginAllowThreads();
32963 (arg1)->SetFocus();
32964 wxPyEndAllowThreads(__tstate);
32965 if (PyErr_Occurred()) SWIG_fail;
32966 }
32967 resultobj = SWIG_Py_Void();
32968 return resultobj;
32969 fail:
32970 return NULL;
32971 }
32972
32973
32974 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32975 PyObject *resultobj = 0;
32976 wxWindow *arg1 = (wxWindow *) 0 ;
32977 void *argp1 = 0 ;
32978 int res1 = 0 ;
32979 PyObject *swig_obj[1] ;
32980
32981 if (!args) SWIG_fail;
32982 swig_obj[0] = args;
32983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32984 if (!SWIG_IsOK(res1)) {
32985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32986 }
32987 arg1 = reinterpret_cast< wxWindow * >(argp1);
32988 {
32989 PyThreadState* __tstate = wxPyBeginAllowThreads();
32990 (arg1)->SetFocusFromKbd();
32991 wxPyEndAllowThreads(__tstate);
32992 if (PyErr_Occurred()) SWIG_fail;
32993 }
32994 resultobj = SWIG_Py_Void();
32995 return resultobj;
32996 fail:
32997 return NULL;
32998 }
32999
33000
33001 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33002 PyObject *resultobj = 0;
33003 wxWindow *result = 0 ;
33004
33005 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33006 {
33007 if (!wxPyCheckForApp()) SWIG_fail;
33008 PyThreadState* __tstate = wxPyBeginAllowThreads();
33009 result = (wxWindow *)wxWindow::FindFocus();
33010 wxPyEndAllowThreads(__tstate);
33011 if (PyErr_Occurred()) SWIG_fail;
33012 }
33013 {
33014 resultobj = wxPyMake_wxObject(result, 0);
33015 }
33016 return resultobj;
33017 fail:
33018 return NULL;
33019 }
33020
33021
33022 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33023 PyObject *resultobj = 0;
33024 wxWindow *arg1 = (wxWindow *) 0 ;
33025 bool result;
33026 void *argp1 = 0 ;
33027 int res1 = 0 ;
33028 PyObject *swig_obj[1] ;
33029
33030 if (!args) SWIG_fail;
33031 swig_obj[0] = args;
33032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33035 }
33036 arg1 = reinterpret_cast< wxWindow * >(argp1);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 {
33044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33045 }
33046 return resultobj;
33047 fail:
33048 return NULL;
33049 }
33050
33051
33052 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33053 PyObject *resultobj = 0;
33054 wxWindow *arg1 = (wxWindow *) 0 ;
33055 bool result;
33056 void *argp1 = 0 ;
33057 int res1 = 0 ;
33058 PyObject *swig_obj[1] ;
33059
33060 if (!args) SWIG_fail;
33061 swig_obj[0] = args;
33062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33063 if (!SWIG_IsOK(res1)) {
33064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33065 }
33066 arg1 = reinterpret_cast< wxWindow * >(argp1);
33067 {
33068 PyThreadState* __tstate = wxPyBeginAllowThreads();
33069 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33070 wxPyEndAllowThreads(__tstate);
33071 if (PyErr_Occurred()) SWIG_fail;
33072 }
33073 {
33074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33075 }
33076 return resultobj;
33077 fail:
33078 return NULL;
33079 }
33080
33081
33082 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33083 PyObject *resultobj = 0;
33084 wxWindow *arg1 = (wxWindow *) 0 ;
33085 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33086 bool result;
33087 void *argp1 = 0 ;
33088 int res1 = 0 ;
33089 int val2 ;
33090 int ecode2 = 0 ;
33091 PyObject * obj0 = 0 ;
33092 PyObject * obj1 = 0 ;
33093 char * kwnames[] = {
33094 (char *) "self",(char *) "flags", NULL
33095 };
33096
33097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33099 if (!SWIG_IsOK(res1)) {
33100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33101 }
33102 arg1 = reinterpret_cast< wxWindow * >(argp1);
33103 if (obj1) {
33104 ecode2 = SWIG_AsVal_int(obj1, &val2);
33105 if (!SWIG_IsOK(ecode2)) {
33106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33107 }
33108 arg2 = static_cast< int >(val2);
33109 }
33110 {
33111 PyThreadState* __tstate = wxPyBeginAllowThreads();
33112 result = (bool)(arg1)->Navigate(arg2);
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 {
33117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33118 }
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33126 PyObject *resultobj = 0;
33127 wxWindow *arg1 = (wxWindow *) 0 ;
33128 wxWindow *arg2 = (wxWindow *) 0 ;
33129 void *argp1 = 0 ;
33130 int res1 = 0 ;
33131 void *argp2 = 0 ;
33132 int res2 = 0 ;
33133 PyObject * obj0 = 0 ;
33134 PyObject * obj1 = 0 ;
33135 char * kwnames[] = {
33136 (char *) "self",(char *) "win", NULL
33137 };
33138
33139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33141 if (!SWIG_IsOK(res1)) {
33142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33143 }
33144 arg1 = reinterpret_cast< wxWindow * >(argp1);
33145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33146 if (!SWIG_IsOK(res2)) {
33147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33148 }
33149 arg2 = reinterpret_cast< wxWindow * >(argp2);
33150 {
33151 PyThreadState* __tstate = wxPyBeginAllowThreads();
33152 (arg1)->MoveAfterInTabOrder(arg2);
33153 wxPyEndAllowThreads(__tstate);
33154 if (PyErr_Occurred()) SWIG_fail;
33155 }
33156 resultobj = SWIG_Py_Void();
33157 return resultobj;
33158 fail:
33159 return NULL;
33160 }
33161
33162
33163 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33164 PyObject *resultobj = 0;
33165 wxWindow *arg1 = (wxWindow *) 0 ;
33166 wxWindow *arg2 = (wxWindow *) 0 ;
33167 void *argp1 = 0 ;
33168 int res1 = 0 ;
33169 void *argp2 = 0 ;
33170 int res2 = 0 ;
33171 PyObject * obj0 = 0 ;
33172 PyObject * obj1 = 0 ;
33173 char * kwnames[] = {
33174 (char *) "self",(char *) "win", NULL
33175 };
33176
33177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33184 if (!SWIG_IsOK(res2)) {
33185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33186 }
33187 arg2 = reinterpret_cast< wxWindow * >(argp2);
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 (arg1)->MoveBeforeInTabOrder(arg2);
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 resultobj = SWIG_Py_Void();
33195 return resultobj;
33196 fail:
33197 return NULL;
33198 }
33199
33200
33201 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33202 PyObject *resultobj = 0;
33203 wxWindow *arg1 = (wxWindow *) 0 ;
33204 PyObject *result = 0 ;
33205 void *argp1 = 0 ;
33206 int res1 = 0 ;
33207 PyObject *swig_obj[1] ;
33208
33209 if (!args) SWIG_fail;
33210 swig_obj[0] = args;
33211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33212 if (!SWIG_IsOK(res1)) {
33213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33214 }
33215 arg1 = reinterpret_cast< wxWindow * >(argp1);
33216 {
33217 PyThreadState* __tstate = wxPyBeginAllowThreads();
33218 result = (PyObject *)wxWindow_GetChildren(arg1);
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 resultobj = result;
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33230 PyObject *resultobj = 0;
33231 wxWindow *arg1 = (wxWindow *) 0 ;
33232 wxWindow *result = 0 ;
33233 void *argp1 = 0 ;
33234 int res1 = 0 ;
33235 PyObject *swig_obj[1] ;
33236
33237 if (!args) SWIG_fail;
33238 swig_obj[0] = args;
33239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33240 if (!SWIG_IsOK(res1)) {
33241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33242 }
33243 arg1 = reinterpret_cast< wxWindow * >(argp1);
33244 {
33245 PyThreadState* __tstate = wxPyBeginAllowThreads();
33246 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33247 wxPyEndAllowThreads(__tstate);
33248 if (PyErr_Occurred()) SWIG_fail;
33249 }
33250 {
33251 resultobj = wxPyMake_wxObject(result, 0);
33252 }
33253 return resultobj;
33254 fail:
33255 return NULL;
33256 }
33257
33258
33259 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33260 PyObject *resultobj = 0;
33261 wxWindow *arg1 = (wxWindow *) 0 ;
33262 wxWindow *result = 0 ;
33263 void *argp1 = 0 ;
33264 int res1 = 0 ;
33265 PyObject *swig_obj[1] ;
33266
33267 if (!args) SWIG_fail;
33268 swig_obj[0] = args;
33269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33270 if (!SWIG_IsOK(res1)) {
33271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33272 }
33273 arg1 = reinterpret_cast< wxWindow * >(argp1);
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 {
33281 resultobj = wxPyMake_wxObject(result, 0);
33282 }
33283 return resultobj;
33284 fail:
33285 return NULL;
33286 }
33287
33288
33289 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33290 PyObject *resultobj = 0;
33291 wxWindow *arg1 = (wxWindow *) 0 ;
33292 bool result;
33293 void *argp1 = 0 ;
33294 int res1 = 0 ;
33295 PyObject *swig_obj[1] ;
33296
33297 if (!args) SWIG_fail;
33298 swig_obj[0] = args;
33299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33300 if (!SWIG_IsOK(res1)) {
33301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33302 }
33303 arg1 = reinterpret_cast< wxWindow * >(argp1);
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 {
33311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33312 }
33313 return resultobj;
33314 fail:
33315 return NULL;
33316 }
33317
33318
33319 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33320 PyObject *resultobj = 0;
33321 wxWindow *arg1 = (wxWindow *) 0 ;
33322 wxWindow *arg2 = (wxWindow *) 0 ;
33323 bool result;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 void *argp2 = 0 ;
33327 int res2 = 0 ;
33328 PyObject * obj0 = 0 ;
33329 PyObject * obj1 = 0 ;
33330 char * kwnames[] = {
33331 (char *) "self",(char *) "newParent", NULL
33332 };
33333
33334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33336 if (!SWIG_IsOK(res1)) {
33337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33338 }
33339 arg1 = reinterpret_cast< wxWindow * >(argp1);
33340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33341 if (!SWIG_IsOK(res2)) {
33342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33343 }
33344 arg2 = reinterpret_cast< wxWindow * >(argp2);
33345 {
33346 PyThreadState* __tstate = wxPyBeginAllowThreads();
33347 result = (bool)(arg1)->Reparent(arg2);
33348 wxPyEndAllowThreads(__tstate);
33349 if (PyErr_Occurred()) SWIG_fail;
33350 }
33351 {
33352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33353 }
33354 return resultobj;
33355 fail:
33356 return NULL;
33357 }
33358
33359
33360 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33361 PyObject *resultobj = 0;
33362 wxWindow *arg1 = (wxWindow *) 0 ;
33363 wxWindow *arg2 = (wxWindow *) 0 ;
33364 void *argp1 = 0 ;
33365 int res1 = 0 ;
33366 void *argp2 = 0 ;
33367 int res2 = 0 ;
33368 PyObject * obj0 = 0 ;
33369 PyObject * obj1 = 0 ;
33370 char * kwnames[] = {
33371 (char *) "self",(char *) "child", NULL
33372 };
33373
33374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33376 if (!SWIG_IsOK(res1)) {
33377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33378 }
33379 arg1 = reinterpret_cast< wxWindow * >(argp1);
33380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33381 if (!SWIG_IsOK(res2)) {
33382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33383 }
33384 arg2 = reinterpret_cast< wxWindow * >(argp2);
33385 {
33386 PyThreadState* __tstate = wxPyBeginAllowThreads();
33387 (arg1)->AddChild(arg2);
33388 wxPyEndAllowThreads(__tstate);
33389 if (PyErr_Occurred()) SWIG_fail;
33390 }
33391 resultobj = SWIG_Py_Void();
33392 return resultobj;
33393 fail:
33394 return NULL;
33395 }
33396
33397
33398 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33399 PyObject *resultobj = 0;
33400 wxWindow *arg1 = (wxWindow *) 0 ;
33401 wxWindow *arg2 = (wxWindow *) 0 ;
33402 void *argp1 = 0 ;
33403 int res1 = 0 ;
33404 void *argp2 = 0 ;
33405 int res2 = 0 ;
33406 PyObject * obj0 = 0 ;
33407 PyObject * obj1 = 0 ;
33408 char * kwnames[] = {
33409 (char *) "self",(char *) "child", NULL
33410 };
33411
33412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33414 if (!SWIG_IsOK(res1)) {
33415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33416 }
33417 arg1 = reinterpret_cast< wxWindow * >(argp1);
33418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33419 if (!SWIG_IsOK(res2)) {
33420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33421 }
33422 arg2 = reinterpret_cast< wxWindow * >(argp2);
33423 {
33424 PyThreadState* __tstate = wxPyBeginAllowThreads();
33425 (arg1)->RemoveChild(arg2);
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 resultobj = SWIG_Py_Void();
33430 return resultobj;
33431 fail:
33432 return NULL;
33433 }
33434
33435
33436 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33437 PyObject *resultobj = 0;
33438 wxWindow *arg1 = (wxWindow *) 0 ;
33439 bool arg2 ;
33440 void *argp1 = 0 ;
33441 int res1 = 0 ;
33442 bool val2 ;
33443 int ecode2 = 0 ;
33444 PyObject * obj0 = 0 ;
33445 PyObject * obj1 = 0 ;
33446 char * kwnames[] = {
33447 (char *) "self",(char *) "on", NULL
33448 };
33449
33450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33452 if (!SWIG_IsOK(res1)) {
33453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33454 }
33455 arg1 = reinterpret_cast< wxWindow * >(argp1);
33456 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33457 if (!SWIG_IsOK(ecode2)) {
33458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33459 }
33460 arg2 = static_cast< bool >(val2);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 (arg1)->SetDoubleBuffered(arg2);
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = SWIG_Py_Void();
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33475 PyObject *resultobj = 0;
33476 wxWindow *arg1 = (wxWindow *) 0 ;
33477 long arg2 ;
33478 wxWindow *result = 0 ;
33479 void *argp1 = 0 ;
33480 int res1 = 0 ;
33481 long val2 ;
33482 int ecode2 = 0 ;
33483 PyObject * obj0 = 0 ;
33484 PyObject * obj1 = 0 ;
33485 char * kwnames[] = {
33486 (char *) "self",(char *) "winid", NULL
33487 };
33488
33489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33491 if (!SWIG_IsOK(res1)) {
33492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33493 }
33494 arg1 = reinterpret_cast< wxWindow * >(argp1);
33495 ecode2 = SWIG_AsVal_long(obj1, &val2);
33496 if (!SWIG_IsOK(ecode2)) {
33497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33498 }
33499 arg2 = static_cast< long >(val2);
33500 {
33501 PyThreadState* __tstate = wxPyBeginAllowThreads();
33502 result = (wxWindow *)(arg1)->FindWindow(arg2);
33503 wxPyEndAllowThreads(__tstate);
33504 if (PyErr_Occurred()) SWIG_fail;
33505 }
33506 {
33507 resultobj = wxPyMake_wxObject(result, 0);
33508 }
33509 return resultobj;
33510 fail:
33511 return NULL;
33512 }
33513
33514
33515 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33516 PyObject *resultobj = 0;
33517 wxWindow *arg1 = (wxWindow *) 0 ;
33518 wxString *arg2 = 0 ;
33519 wxWindow *result = 0 ;
33520 void *argp1 = 0 ;
33521 int res1 = 0 ;
33522 bool temp2 = false ;
33523 PyObject * obj0 = 0 ;
33524 PyObject * obj1 = 0 ;
33525 char * kwnames[] = {
33526 (char *) "self",(char *) "name", NULL
33527 };
33528
33529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33531 if (!SWIG_IsOK(res1)) {
33532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33533 }
33534 arg1 = reinterpret_cast< wxWindow * >(argp1);
33535 {
33536 arg2 = wxString_in_helper(obj1);
33537 if (arg2 == NULL) SWIG_fail;
33538 temp2 = true;
33539 }
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 {
33547 resultobj = wxPyMake_wxObject(result, 0);
33548 }
33549 {
33550 if (temp2)
33551 delete arg2;
33552 }
33553 return resultobj;
33554 fail:
33555 {
33556 if (temp2)
33557 delete arg2;
33558 }
33559 return NULL;
33560 }
33561
33562
33563 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33564 PyObject *resultobj = 0;
33565 wxWindow *arg1 = (wxWindow *) 0 ;
33566 wxEvtHandler *result = 0 ;
33567 void *argp1 = 0 ;
33568 int res1 = 0 ;
33569 PyObject *swig_obj[1] ;
33570
33571 if (!args) SWIG_fail;
33572 swig_obj[0] = args;
33573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33574 if (!SWIG_IsOK(res1)) {
33575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33576 }
33577 arg1 = reinterpret_cast< wxWindow * >(argp1);
33578 {
33579 PyThreadState* __tstate = wxPyBeginAllowThreads();
33580 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33581 wxPyEndAllowThreads(__tstate);
33582 if (PyErr_Occurred()) SWIG_fail;
33583 }
33584 {
33585 resultobj = wxPyMake_wxObject(result, 0);
33586 }
33587 return resultobj;
33588 fail:
33589 return NULL;
33590 }
33591
33592
33593 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33594 PyObject *resultobj = 0;
33595 wxWindow *arg1 = (wxWindow *) 0 ;
33596 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33597 void *argp1 = 0 ;
33598 int res1 = 0 ;
33599 void *argp2 = 0 ;
33600 int res2 = 0 ;
33601 PyObject * obj0 = 0 ;
33602 PyObject * obj1 = 0 ;
33603 char * kwnames[] = {
33604 (char *) "self",(char *) "handler", NULL
33605 };
33606
33607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33609 if (!SWIG_IsOK(res1)) {
33610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33611 }
33612 arg1 = reinterpret_cast< wxWindow * >(argp1);
33613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33614 if (!SWIG_IsOK(res2)) {
33615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33616 }
33617 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33618 {
33619 PyThreadState* __tstate = wxPyBeginAllowThreads();
33620 (arg1)->SetEventHandler(arg2);
33621 wxPyEndAllowThreads(__tstate);
33622 if (PyErr_Occurred()) SWIG_fail;
33623 }
33624 resultobj = SWIG_Py_Void();
33625 return resultobj;
33626 fail:
33627 return NULL;
33628 }
33629
33630
33631 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33632 PyObject *resultobj = 0;
33633 wxWindow *arg1 = (wxWindow *) 0 ;
33634 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33635 void *argp1 = 0 ;
33636 int res1 = 0 ;
33637 void *argp2 = 0 ;
33638 int res2 = 0 ;
33639 PyObject * obj0 = 0 ;
33640 PyObject * obj1 = 0 ;
33641 char * kwnames[] = {
33642 (char *) "self",(char *) "handler", NULL
33643 };
33644
33645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33647 if (!SWIG_IsOK(res1)) {
33648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33649 }
33650 arg1 = reinterpret_cast< wxWindow * >(argp1);
33651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33652 if (!SWIG_IsOK(res2)) {
33653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33654 }
33655 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33656 {
33657 PyThreadState* __tstate = wxPyBeginAllowThreads();
33658 (arg1)->PushEventHandler(arg2);
33659 wxPyEndAllowThreads(__tstate);
33660 if (PyErr_Occurred()) SWIG_fail;
33661 }
33662 resultobj = SWIG_Py_Void();
33663 return resultobj;
33664 fail:
33665 return NULL;
33666 }
33667
33668
33669 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33670 PyObject *resultobj = 0;
33671 wxWindow *arg1 = (wxWindow *) 0 ;
33672 bool arg2 = (bool) false ;
33673 wxEvtHandler *result = 0 ;
33674 void *argp1 = 0 ;
33675 int res1 = 0 ;
33676 bool val2 ;
33677 int ecode2 = 0 ;
33678 PyObject * obj0 = 0 ;
33679 PyObject * obj1 = 0 ;
33680 char * kwnames[] = {
33681 (char *) "self",(char *) "deleteHandler", NULL
33682 };
33683
33684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) 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_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33688 }
33689 arg1 = reinterpret_cast< wxWindow * >(argp1);
33690 if (obj1) {
33691 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33692 if (!SWIG_IsOK(ecode2)) {
33693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33694 }
33695 arg2 = static_cast< bool >(val2);
33696 }
33697 {
33698 PyThreadState* __tstate = wxPyBeginAllowThreads();
33699 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33700 wxPyEndAllowThreads(__tstate);
33701 if (PyErr_Occurred()) SWIG_fail;
33702 }
33703 {
33704 resultobj = wxPyMake_wxObject(result, 0);
33705 }
33706 return resultobj;
33707 fail:
33708 return NULL;
33709 }
33710
33711
33712 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33713 PyObject *resultobj = 0;
33714 wxWindow *arg1 = (wxWindow *) 0 ;
33715 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33716 bool result;
33717 void *argp1 = 0 ;
33718 int res1 = 0 ;
33719 void *argp2 = 0 ;
33720 int res2 = 0 ;
33721 PyObject * obj0 = 0 ;
33722 PyObject * obj1 = 0 ;
33723 char * kwnames[] = {
33724 (char *) "self",(char *) "handler", NULL
33725 };
33726
33727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33729 if (!SWIG_IsOK(res1)) {
33730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33731 }
33732 arg1 = reinterpret_cast< wxWindow * >(argp1);
33733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33734 if (!SWIG_IsOK(res2)) {
33735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33736 }
33737 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33738 {
33739 PyThreadState* __tstate = wxPyBeginAllowThreads();
33740 result = (bool)(arg1)->RemoveEventHandler(arg2);
33741 wxPyEndAllowThreads(__tstate);
33742 if (PyErr_Occurred()) SWIG_fail;
33743 }
33744 {
33745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33746 }
33747 return resultobj;
33748 fail:
33749 return NULL;
33750 }
33751
33752
33753 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33754 PyObject *resultobj = 0;
33755 wxWindow *arg1 = (wxWindow *) 0 ;
33756 wxValidator *arg2 = 0 ;
33757 void *argp1 = 0 ;
33758 int res1 = 0 ;
33759 void *argp2 = 0 ;
33760 int res2 = 0 ;
33761 PyObject * obj0 = 0 ;
33762 PyObject * obj1 = 0 ;
33763 char * kwnames[] = {
33764 (char *) "self",(char *) "validator", NULL
33765 };
33766
33767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33769 if (!SWIG_IsOK(res1)) {
33770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33771 }
33772 arg1 = reinterpret_cast< wxWindow * >(argp1);
33773 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33774 if (!SWIG_IsOK(res2)) {
33775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33776 }
33777 if (!argp2) {
33778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33779 }
33780 arg2 = reinterpret_cast< wxValidator * >(argp2);
33781 {
33782 PyThreadState* __tstate = wxPyBeginAllowThreads();
33783 (arg1)->SetValidator((wxValidator const &)*arg2);
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 resultobj = SWIG_Py_Void();
33788 return resultobj;
33789 fail:
33790 return NULL;
33791 }
33792
33793
33794 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33795 PyObject *resultobj = 0;
33796 wxWindow *arg1 = (wxWindow *) 0 ;
33797 wxValidator *result = 0 ;
33798 void *argp1 = 0 ;
33799 int res1 = 0 ;
33800 PyObject *swig_obj[1] ;
33801
33802 if (!args) SWIG_fail;
33803 swig_obj[0] = args;
33804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33805 if (!SWIG_IsOK(res1)) {
33806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33807 }
33808 arg1 = reinterpret_cast< wxWindow * >(argp1);
33809 {
33810 PyThreadState* __tstate = wxPyBeginAllowThreads();
33811 result = (wxValidator *)(arg1)->GetValidator();
33812 wxPyEndAllowThreads(__tstate);
33813 if (PyErr_Occurred()) SWIG_fail;
33814 }
33815 {
33816 resultobj = wxPyMake_wxObject(result, (bool)0);
33817 }
33818 return resultobj;
33819 fail:
33820 return NULL;
33821 }
33822
33823
33824 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33825 PyObject *resultobj = 0;
33826 wxWindow *arg1 = (wxWindow *) 0 ;
33827 bool result;
33828 void *argp1 = 0 ;
33829 int res1 = 0 ;
33830 PyObject *swig_obj[1] ;
33831
33832 if (!args) SWIG_fail;
33833 swig_obj[0] = args;
33834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33835 if (!SWIG_IsOK(res1)) {
33836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33837 }
33838 arg1 = reinterpret_cast< wxWindow * >(argp1);
33839 {
33840 PyThreadState* __tstate = wxPyBeginAllowThreads();
33841 result = (bool)(arg1)->Validate();
33842 wxPyEndAllowThreads(__tstate);
33843 if (PyErr_Occurred()) SWIG_fail;
33844 }
33845 {
33846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33847 }
33848 return resultobj;
33849 fail:
33850 return NULL;
33851 }
33852
33853
33854 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33855 PyObject *resultobj = 0;
33856 wxWindow *arg1 = (wxWindow *) 0 ;
33857 bool result;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 PyObject *swig_obj[1] ;
33861
33862 if (!args) SWIG_fail;
33863 swig_obj[0] = args;
33864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33865 if (!SWIG_IsOK(res1)) {
33866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33867 }
33868 arg1 = reinterpret_cast< wxWindow * >(argp1);
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 result = (bool)(arg1)->TransferDataToWindow();
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 {
33876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33877 }
33878 return resultobj;
33879 fail:
33880 return NULL;
33881 }
33882
33883
33884 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33885 PyObject *resultobj = 0;
33886 wxWindow *arg1 = (wxWindow *) 0 ;
33887 bool result;
33888 void *argp1 = 0 ;
33889 int res1 = 0 ;
33890 PyObject *swig_obj[1] ;
33891
33892 if (!args) SWIG_fail;
33893 swig_obj[0] = args;
33894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33895 if (!SWIG_IsOK(res1)) {
33896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33897 }
33898 arg1 = reinterpret_cast< wxWindow * >(argp1);
33899 {
33900 PyThreadState* __tstate = wxPyBeginAllowThreads();
33901 result = (bool)(arg1)->TransferDataFromWindow();
33902 wxPyEndAllowThreads(__tstate);
33903 if (PyErr_Occurred()) SWIG_fail;
33904 }
33905 {
33906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33907 }
33908 return resultobj;
33909 fail:
33910 return NULL;
33911 }
33912
33913
33914 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33915 PyObject *resultobj = 0;
33916 wxWindow *arg1 = (wxWindow *) 0 ;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 PyObject *swig_obj[1] ;
33920
33921 if (!args) SWIG_fail;
33922 swig_obj[0] = args;
33923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33924 if (!SWIG_IsOK(res1)) {
33925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33926 }
33927 arg1 = reinterpret_cast< wxWindow * >(argp1);
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 (arg1)->InitDialog();
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 resultobj = SWIG_Py_Void();
33935 return resultobj;
33936 fail:
33937 return NULL;
33938 }
33939
33940
33941 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33942 PyObject *resultobj = 0;
33943 wxWindow *arg1 = (wxWindow *) 0 ;
33944 wxAcceleratorTable *arg2 = 0 ;
33945 void *argp1 = 0 ;
33946 int res1 = 0 ;
33947 void *argp2 = 0 ;
33948 int res2 = 0 ;
33949 PyObject * obj0 = 0 ;
33950 PyObject * obj1 = 0 ;
33951 char * kwnames[] = {
33952 (char *) "self",(char *) "accel", NULL
33953 };
33954
33955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33957 if (!SWIG_IsOK(res1)) {
33958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33959 }
33960 arg1 = reinterpret_cast< wxWindow * >(argp1);
33961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33962 if (!SWIG_IsOK(res2)) {
33963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33964 }
33965 if (!argp2) {
33966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33967 }
33968 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_Py_Void();
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33983 PyObject *resultobj = 0;
33984 wxWindow *arg1 = (wxWindow *) 0 ;
33985 wxAcceleratorTable *result = 0 ;
33986 void *argp1 = 0 ;
33987 int res1 = 0 ;
33988 PyObject *swig_obj[1] ;
33989
33990 if (!args) SWIG_fail;
33991 swig_obj[0] = args;
33992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33995 }
33996 arg1 = reinterpret_cast< wxWindow * >(argp1);
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34011 PyObject *resultobj = 0;
34012 wxWindow *arg1 = (wxWindow *) 0 ;
34013 int arg2 ;
34014 int arg3 ;
34015 int arg4 ;
34016 bool result;
34017 void *argp1 = 0 ;
34018 int res1 = 0 ;
34019 int val2 ;
34020 int ecode2 = 0 ;
34021 int val3 ;
34022 int ecode3 = 0 ;
34023 int val4 ;
34024 int ecode4 = 0 ;
34025 PyObject * obj0 = 0 ;
34026 PyObject * obj1 = 0 ;
34027 PyObject * obj2 = 0 ;
34028 PyObject * obj3 = 0 ;
34029 char * kwnames[] = {
34030 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34031 };
34032
34033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34035 if (!SWIG_IsOK(res1)) {
34036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34037 }
34038 arg1 = reinterpret_cast< wxWindow * >(argp1);
34039 ecode2 = SWIG_AsVal_int(obj1, &val2);
34040 if (!SWIG_IsOK(ecode2)) {
34041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34042 }
34043 arg2 = static_cast< int >(val2);
34044 ecode3 = SWIG_AsVal_int(obj2, &val3);
34045 if (!SWIG_IsOK(ecode3)) {
34046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34047 }
34048 arg3 = static_cast< int >(val3);
34049 ecode4 = SWIG_AsVal_int(obj3, &val4);
34050 if (!SWIG_IsOK(ecode4)) {
34051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34052 }
34053 arg4 = static_cast< int >(val4);
34054 {
34055 PyThreadState* __tstate = wxPyBeginAllowThreads();
34056 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34057 wxPyEndAllowThreads(__tstate);
34058 if (PyErr_Occurred()) SWIG_fail;
34059 }
34060 {
34061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34062 }
34063 return resultobj;
34064 fail:
34065 return NULL;
34066 }
34067
34068
34069 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34070 PyObject *resultobj = 0;
34071 wxWindow *arg1 = (wxWindow *) 0 ;
34072 int arg2 ;
34073 bool result;
34074 void *argp1 = 0 ;
34075 int res1 = 0 ;
34076 int val2 ;
34077 int ecode2 = 0 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "hotkeyId", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34088 }
34089 arg1 = reinterpret_cast< wxWindow * >(argp1);
34090 ecode2 = SWIG_AsVal_int(obj1, &val2);
34091 if (!SWIG_IsOK(ecode2)) {
34092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34093 }
34094 arg2 = static_cast< int >(val2);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 {
34102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34103 }
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34111 PyObject *resultobj = 0;
34112 wxWindow *arg1 = (wxWindow *) 0 ;
34113 wxPoint *arg2 = 0 ;
34114 wxPoint result;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 wxPoint temp2 ;
34118 PyObject * obj0 = 0 ;
34119 PyObject * obj1 = 0 ;
34120 char * kwnames[] = {
34121 (char *) "self",(char *) "pt", NULL
34122 };
34123
34124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34126 if (!SWIG_IsOK(res1)) {
34127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34128 }
34129 arg1 = reinterpret_cast< wxWindow * >(argp1);
34130 {
34131 arg2 = &temp2;
34132 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34133 }
34134 {
34135 PyThreadState* __tstate = wxPyBeginAllowThreads();
34136 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34137 wxPyEndAllowThreads(__tstate);
34138 if (PyErr_Occurred()) SWIG_fail;
34139 }
34140 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34141 return resultobj;
34142 fail:
34143 return NULL;
34144 }
34145
34146
34147 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34148 PyObject *resultobj = 0;
34149 wxWindow *arg1 = (wxWindow *) 0 ;
34150 wxSize *arg2 = 0 ;
34151 wxSize result;
34152 void *argp1 = 0 ;
34153 int res1 = 0 ;
34154 wxSize temp2 ;
34155 PyObject * obj0 = 0 ;
34156 PyObject * obj1 = 0 ;
34157 char * kwnames[] = {
34158 (char *) "self",(char *) "sz", NULL
34159 };
34160
34161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34163 if (!SWIG_IsOK(res1)) {
34164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34165 }
34166 arg1 = reinterpret_cast< wxWindow * >(argp1);
34167 {
34168 arg2 = &temp2;
34169 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34170 }
34171 {
34172 PyThreadState* __tstate = wxPyBeginAllowThreads();
34173 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34174 wxPyEndAllowThreads(__tstate);
34175 if (PyErr_Occurred()) SWIG_fail;
34176 }
34177 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34178 return resultobj;
34179 fail:
34180 return NULL;
34181 }
34182
34183
34184 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34185 PyObject *resultobj = 0;
34186 wxWindow *arg1 = (wxWindow *) 0 ;
34187 wxPoint *arg2 = 0 ;
34188 wxPoint result;
34189 void *argp1 = 0 ;
34190 int res1 = 0 ;
34191 wxPoint temp2 ;
34192 PyObject * obj0 = 0 ;
34193 PyObject * obj1 = 0 ;
34194 char * kwnames[] = {
34195 (char *) "self",(char *) "pt", NULL
34196 };
34197
34198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34200 if (!SWIG_IsOK(res1)) {
34201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34202 }
34203 arg1 = reinterpret_cast< wxWindow * >(argp1);
34204 {
34205 arg2 = &temp2;
34206 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34207 }
34208 {
34209 PyThreadState* __tstate = wxPyBeginAllowThreads();
34210 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34211 wxPyEndAllowThreads(__tstate);
34212 if (PyErr_Occurred()) SWIG_fail;
34213 }
34214 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34215 return resultobj;
34216 fail:
34217 return NULL;
34218 }
34219
34220
34221 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34222 PyObject *resultobj = 0;
34223 wxWindow *arg1 = (wxWindow *) 0 ;
34224 wxSize *arg2 = 0 ;
34225 wxSize result;
34226 void *argp1 = 0 ;
34227 int res1 = 0 ;
34228 wxSize temp2 ;
34229 PyObject * obj0 = 0 ;
34230 PyObject * obj1 = 0 ;
34231 char * kwnames[] = {
34232 (char *) "self",(char *) "sz", NULL
34233 };
34234
34235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34237 if (!SWIG_IsOK(res1)) {
34238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34239 }
34240 arg1 = reinterpret_cast< wxWindow * >(argp1);
34241 {
34242 arg2 = &temp2;
34243 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34244 }
34245 {
34246 PyThreadState* __tstate = wxPyBeginAllowThreads();
34247 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34248 wxPyEndAllowThreads(__tstate);
34249 if (PyErr_Occurred()) SWIG_fail;
34250 }
34251 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34252 return resultobj;
34253 fail:
34254 return NULL;
34255 }
34256
34257
34258 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34259 PyObject *resultobj = 0;
34260 wxWindow *arg1 = (wxWindow *) 0 ;
34261 wxPoint *arg2 = 0 ;
34262 wxPoint result;
34263 void *argp1 = 0 ;
34264 int res1 = 0 ;
34265 wxPoint temp2 ;
34266 PyObject * obj0 = 0 ;
34267 PyObject * obj1 = 0 ;
34268 char * kwnames[] = {
34269 (char *) "self",(char *) "pt", NULL
34270 };
34271
34272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34274 if (!SWIG_IsOK(res1)) {
34275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34276 }
34277 arg1 = reinterpret_cast< wxWindow * >(argp1);
34278 {
34279 arg2 = &temp2;
34280 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34281 }
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34285 wxPyEndAllowThreads(__tstate);
34286 if (PyErr_Occurred()) SWIG_fail;
34287 }
34288 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34296 PyObject *resultobj = 0;
34297 wxWindow *arg1 = (wxWindow *) 0 ;
34298 wxSize *arg2 = 0 ;
34299 wxSize result;
34300 void *argp1 = 0 ;
34301 int res1 = 0 ;
34302 wxSize temp2 ;
34303 PyObject * obj0 = 0 ;
34304 PyObject * obj1 = 0 ;
34305 char * kwnames[] = {
34306 (char *) "self",(char *) "sz", NULL
34307 };
34308
34309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34311 if (!SWIG_IsOK(res1)) {
34312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34313 }
34314 arg1 = reinterpret_cast< wxWindow * >(argp1);
34315 {
34316 arg2 = &temp2;
34317 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34318 }
34319 {
34320 PyThreadState* __tstate = wxPyBeginAllowThreads();
34321 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34322 wxPyEndAllowThreads(__tstate);
34323 if (PyErr_Occurred()) SWIG_fail;
34324 }
34325 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34326 return resultobj;
34327 fail:
34328 return NULL;
34329 }
34330
34331
34332 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34333 PyObject *resultobj = 0;
34334 wxWindow *arg1 = (wxWindow *) 0 ;
34335 int arg2 ;
34336 int arg3 ;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 int val2 ;
34340 int ecode2 = 0 ;
34341 int val3 ;
34342 int ecode3 = 0 ;
34343 PyObject * obj0 = 0 ;
34344 PyObject * obj1 = 0 ;
34345 PyObject * obj2 = 0 ;
34346 char * kwnames[] = {
34347 (char *) "self",(char *) "x",(char *) "y", NULL
34348 };
34349
34350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34352 if (!SWIG_IsOK(res1)) {
34353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34354 }
34355 arg1 = reinterpret_cast< wxWindow * >(argp1);
34356 ecode2 = SWIG_AsVal_int(obj1, &val2);
34357 if (!SWIG_IsOK(ecode2)) {
34358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34359 }
34360 arg2 = static_cast< int >(val2);
34361 ecode3 = SWIG_AsVal_int(obj2, &val3);
34362 if (!SWIG_IsOK(ecode3)) {
34363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34364 }
34365 arg3 = static_cast< int >(val3);
34366 {
34367 PyThreadState* __tstate = wxPyBeginAllowThreads();
34368 (arg1)->WarpPointer(arg2,arg3);
34369 wxPyEndAllowThreads(__tstate);
34370 if (PyErr_Occurred()) SWIG_fail;
34371 }
34372 resultobj = SWIG_Py_Void();
34373 return resultobj;
34374 fail:
34375 return NULL;
34376 }
34377
34378
34379 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34380 PyObject *resultobj = 0;
34381 wxWindow *arg1 = (wxWindow *) 0 ;
34382 void *argp1 = 0 ;
34383 int res1 = 0 ;
34384 PyObject *swig_obj[1] ;
34385
34386 if (!args) SWIG_fail;
34387 swig_obj[0] = args;
34388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34389 if (!SWIG_IsOK(res1)) {
34390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34391 }
34392 arg1 = reinterpret_cast< wxWindow * >(argp1);
34393 {
34394 PyThreadState* __tstate = wxPyBeginAllowThreads();
34395 (arg1)->CaptureMouse();
34396 wxPyEndAllowThreads(__tstate);
34397 if (PyErr_Occurred()) SWIG_fail;
34398 }
34399 resultobj = SWIG_Py_Void();
34400 return resultobj;
34401 fail:
34402 return NULL;
34403 }
34404
34405
34406 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34407 PyObject *resultobj = 0;
34408 wxWindow *arg1 = (wxWindow *) 0 ;
34409 void *argp1 = 0 ;
34410 int res1 = 0 ;
34411 PyObject *swig_obj[1] ;
34412
34413 if (!args) SWIG_fail;
34414 swig_obj[0] = args;
34415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34416 if (!SWIG_IsOK(res1)) {
34417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34418 }
34419 arg1 = reinterpret_cast< wxWindow * >(argp1);
34420 {
34421 PyThreadState* __tstate = wxPyBeginAllowThreads();
34422 (arg1)->ReleaseMouse();
34423 wxPyEndAllowThreads(__tstate);
34424 if (PyErr_Occurred()) SWIG_fail;
34425 }
34426 resultobj = SWIG_Py_Void();
34427 return resultobj;
34428 fail:
34429 return NULL;
34430 }
34431
34432
34433 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34434 PyObject *resultobj = 0;
34435 wxWindow *result = 0 ;
34436
34437 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34438 {
34439 if (!wxPyCheckForApp()) SWIG_fail;
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 result = (wxWindow *)wxWindow::GetCapture();
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 {
34446 resultobj = wxPyMake_wxObject(result, 0);
34447 }
34448 return resultobj;
34449 fail:
34450 return NULL;
34451 }
34452
34453
34454 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34455 PyObject *resultobj = 0;
34456 wxWindow *arg1 = (wxWindow *) 0 ;
34457 bool result;
34458 void *argp1 = 0 ;
34459 int res1 = 0 ;
34460 PyObject *swig_obj[1] ;
34461
34462 if (!args) SWIG_fail;
34463 swig_obj[0] = args;
34464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34465 if (!SWIG_IsOK(res1)) {
34466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34467 }
34468 arg1 = reinterpret_cast< wxWindow * >(argp1);
34469 {
34470 PyThreadState* __tstate = wxPyBeginAllowThreads();
34471 result = (bool)((wxWindow const *)arg1)->HasCapture();
34472 wxPyEndAllowThreads(__tstate);
34473 if (PyErr_Occurred()) SWIG_fail;
34474 }
34475 {
34476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34477 }
34478 return resultobj;
34479 fail:
34480 return NULL;
34481 }
34482
34483
34484 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34485 PyObject *resultobj = 0;
34486 wxWindow *arg1 = (wxWindow *) 0 ;
34487 bool arg2 = (bool) true ;
34488 wxRect *arg3 = (wxRect *) NULL ;
34489 void *argp1 = 0 ;
34490 int res1 = 0 ;
34491 bool val2 ;
34492 int ecode2 = 0 ;
34493 void *argp3 = 0 ;
34494 int res3 = 0 ;
34495 PyObject * obj0 = 0 ;
34496 PyObject * obj1 = 0 ;
34497 PyObject * obj2 = 0 ;
34498 char * kwnames[] = {
34499 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34500 };
34501
34502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34504 if (!SWIG_IsOK(res1)) {
34505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34506 }
34507 arg1 = reinterpret_cast< wxWindow * >(argp1);
34508 if (obj1) {
34509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34510 if (!SWIG_IsOK(ecode2)) {
34511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34512 }
34513 arg2 = static_cast< bool >(val2);
34514 }
34515 if (obj2) {
34516 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34517 if (!SWIG_IsOK(res3)) {
34518 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34519 }
34520 arg3 = reinterpret_cast< wxRect * >(argp3);
34521 }
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 resultobj = SWIG_Py_Void();
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34536 PyObject *resultobj = 0;
34537 wxWindow *arg1 = (wxWindow *) 0 ;
34538 wxRect *arg2 = 0 ;
34539 bool arg3 = (bool) true ;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 wxRect temp2 ;
34543 bool val3 ;
34544 int ecode3 = 0 ;
34545 PyObject * obj0 = 0 ;
34546 PyObject * obj1 = 0 ;
34547 PyObject * obj2 = 0 ;
34548 char * kwnames[] = {
34549 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34550 };
34551
34552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34554 if (!SWIG_IsOK(res1)) {
34555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34556 }
34557 arg1 = reinterpret_cast< wxWindow * >(argp1);
34558 {
34559 arg2 = &temp2;
34560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34561 }
34562 if (obj2) {
34563 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34564 if (!SWIG_IsOK(ecode3)) {
34565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34566 }
34567 arg3 = static_cast< bool >(val3);
34568 }
34569 {
34570 PyThreadState* __tstate = wxPyBeginAllowThreads();
34571 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34572 wxPyEndAllowThreads(__tstate);
34573 if (PyErr_Occurred()) SWIG_fail;
34574 }
34575 resultobj = SWIG_Py_Void();
34576 return resultobj;
34577 fail:
34578 return NULL;
34579 }
34580
34581
34582 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34583 PyObject *resultobj = 0;
34584 wxWindow *arg1 = (wxWindow *) 0 ;
34585 void *argp1 = 0 ;
34586 int res1 = 0 ;
34587 PyObject *swig_obj[1] ;
34588
34589 if (!args) SWIG_fail;
34590 swig_obj[0] = args;
34591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34592 if (!SWIG_IsOK(res1)) {
34593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34594 }
34595 arg1 = reinterpret_cast< wxWindow * >(argp1);
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 (arg1)->Update();
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 resultobj = SWIG_Py_Void();
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 void *argp1 = 0 ;
34613 int res1 = 0 ;
34614 PyObject *swig_obj[1] ;
34615
34616 if (!args) SWIG_fail;
34617 swig_obj[0] = args;
34618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34619 if (!SWIG_IsOK(res1)) {
34620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34621 }
34622 arg1 = reinterpret_cast< wxWindow * >(argp1);
34623 {
34624 PyThreadState* __tstate = wxPyBeginAllowThreads();
34625 (arg1)->ClearBackground();
34626 wxPyEndAllowThreads(__tstate);
34627 if (PyErr_Occurred()) SWIG_fail;
34628 }
34629 resultobj = SWIG_Py_Void();
34630 return resultobj;
34631 fail:
34632 return NULL;
34633 }
34634
34635
34636 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34637 PyObject *resultobj = 0;
34638 wxWindow *arg1 = (wxWindow *) 0 ;
34639 void *argp1 = 0 ;
34640 int res1 = 0 ;
34641 PyObject *swig_obj[1] ;
34642
34643 if (!args) SWIG_fail;
34644 swig_obj[0] = args;
34645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34646 if (!SWIG_IsOK(res1)) {
34647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34648 }
34649 arg1 = reinterpret_cast< wxWindow * >(argp1);
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 (arg1)->Freeze();
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 resultobj = SWIG_Py_Void();
34657 return resultobj;
34658 fail:
34659 return NULL;
34660 }
34661
34662
34663 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34664 PyObject *resultobj = 0;
34665 wxWindow *arg1 = (wxWindow *) 0 ;
34666 void *argp1 = 0 ;
34667 int res1 = 0 ;
34668 PyObject *swig_obj[1] ;
34669
34670 if (!args) SWIG_fail;
34671 swig_obj[0] = args;
34672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34673 if (!SWIG_IsOK(res1)) {
34674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34675 }
34676 arg1 = reinterpret_cast< wxWindow * >(argp1);
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 (arg1)->Thaw();
34680 wxPyEndAllowThreads(__tstate);
34681 if (PyErr_Occurred()) SWIG_fail;
34682 }
34683 resultobj = SWIG_Py_Void();
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj = 0;
34692 wxWindow *arg1 = (wxWindow *) 0 ;
34693 wxDC *arg2 = 0 ;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 void *argp2 = 0 ;
34697 int res2 = 0 ;
34698 PyObject * obj0 = 0 ;
34699 PyObject * obj1 = 0 ;
34700 char * kwnames[] = {
34701 (char *) "self",(char *) "dc", NULL
34702 };
34703
34704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34706 if (!SWIG_IsOK(res1)) {
34707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34708 }
34709 arg1 = reinterpret_cast< wxWindow * >(argp1);
34710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34711 if (!SWIG_IsOK(res2)) {
34712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34713 }
34714 if (!argp2) {
34715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34716 }
34717 arg2 = reinterpret_cast< wxDC * >(argp2);
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 (arg1)->PrepareDC(*arg2);
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 resultobj = SWIG_Py_Void();
34725 return resultobj;
34726 fail:
34727 return NULL;
34728 }
34729
34730
34731 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34732 PyObject *resultobj = 0;
34733 wxWindow *arg1 = (wxWindow *) 0 ;
34734 wxRegion *result = 0 ;
34735 void *argp1 = 0 ;
34736 int res1 = 0 ;
34737 PyObject *swig_obj[1] ;
34738
34739 if (!args) SWIG_fail;
34740 swig_obj[0] = args;
34741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34742 if (!SWIG_IsOK(res1)) {
34743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34744 }
34745 arg1 = reinterpret_cast< wxWindow * >(argp1);
34746 {
34747 PyThreadState* __tstate = wxPyBeginAllowThreads();
34748 {
34749 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34750 result = (wxRegion *) &_result_ref;
34751 }
34752 wxPyEndAllowThreads(__tstate);
34753 if (PyErr_Occurred()) SWIG_fail;
34754 }
34755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34756 return resultobj;
34757 fail:
34758 return NULL;
34759 }
34760
34761
34762 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34763 PyObject *resultobj = 0;
34764 wxWindow *arg1 = (wxWindow *) 0 ;
34765 wxRect result;
34766 void *argp1 = 0 ;
34767 int res1 = 0 ;
34768 PyObject *swig_obj[1] ;
34769
34770 if (!args) SWIG_fail;
34771 swig_obj[0] = args;
34772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34773 if (!SWIG_IsOK(res1)) {
34774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34775 }
34776 arg1 = reinterpret_cast< wxWindow * >(argp1);
34777 {
34778 PyThreadState* __tstate = wxPyBeginAllowThreads();
34779 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34780 wxPyEndAllowThreads(__tstate);
34781 if (PyErr_Occurred()) SWIG_fail;
34782 }
34783 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34784 return resultobj;
34785 fail:
34786 return NULL;
34787 }
34788
34789
34790 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34791 PyObject *resultobj = 0;
34792 wxWindow *arg1 = (wxWindow *) 0 ;
34793 int arg2 ;
34794 int arg3 ;
34795 int arg4 = (int) 1 ;
34796 int arg5 = (int) 1 ;
34797 bool result;
34798 void *argp1 = 0 ;
34799 int res1 = 0 ;
34800 int val2 ;
34801 int ecode2 = 0 ;
34802 int val3 ;
34803 int ecode3 = 0 ;
34804 int val4 ;
34805 int ecode4 = 0 ;
34806 int val5 ;
34807 int ecode5 = 0 ;
34808 PyObject * obj0 = 0 ;
34809 PyObject * obj1 = 0 ;
34810 PyObject * obj2 = 0 ;
34811 PyObject * obj3 = 0 ;
34812 PyObject * obj4 = 0 ;
34813 char * kwnames[] = {
34814 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34815 };
34816
34817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34821 }
34822 arg1 = reinterpret_cast< wxWindow * >(argp1);
34823 ecode2 = SWIG_AsVal_int(obj1, &val2);
34824 if (!SWIG_IsOK(ecode2)) {
34825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34826 }
34827 arg2 = static_cast< int >(val2);
34828 ecode3 = SWIG_AsVal_int(obj2, &val3);
34829 if (!SWIG_IsOK(ecode3)) {
34830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34831 }
34832 arg3 = static_cast< int >(val3);
34833 if (obj3) {
34834 ecode4 = SWIG_AsVal_int(obj3, &val4);
34835 if (!SWIG_IsOK(ecode4)) {
34836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34837 }
34838 arg4 = static_cast< int >(val4);
34839 }
34840 if (obj4) {
34841 ecode5 = SWIG_AsVal_int(obj4, &val5);
34842 if (!SWIG_IsOK(ecode5)) {
34843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34844 }
34845 arg5 = static_cast< int >(val5);
34846 }
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34850 wxPyEndAllowThreads(__tstate);
34851 if (PyErr_Occurred()) SWIG_fail;
34852 }
34853 {
34854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34855 }
34856 return resultobj;
34857 fail:
34858 return NULL;
34859 }
34860
34861
34862 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34863 PyObject *resultobj = 0;
34864 wxWindow *arg1 = (wxWindow *) 0 ;
34865 wxPoint *arg2 = 0 ;
34866 bool result;
34867 void *argp1 = 0 ;
34868 int res1 = 0 ;
34869 wxPoint temp2 ;
34870 PyObject * obj0 = 0 ;
34871 PyObject * obj1 = 0 ;
34872 char * kwnames[] = {
34873 (char *) "self",(char *) "pt", NULL
34874 };
34875
34876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34878 if (!SWIG_IsOK(res1)) {
34879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34880 }
34881 arg1 = reinterpret_cast< wxWindow * >(argp1);
34882 {
34883 arg2 = &temp2;
34884 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34885 }
34886 {
34887 PyThreadState* __tstate = wxPyBeginAllowThreads();
34888 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34889 wxPyEndAllowThreads(__tstate);
34890 if (PyErr_Occurred()) SWIG_fail;
34891 }
34892 {
34893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34894 }
34895 return resultobj;
34896 fail:
34897 return NULL;
34898 }
34899
34900
34901 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34902 PyObject *resultobj = 0;
34903 wxWindow *arg1 = (wxWindow *) 0 ;
34904 wxRect *arg2 = 0 ;
34905 bool result;
34906 void *argp1 = 0 ;
34907 int res1 = 0 ;
34908 wxRect temp2 ;
34909 PyObject * obj0 = 0 ;
34910 PyObject * obj1 = 0 ;
34911 char * kwnames[] = {
34912 (char *) "self",(char *) "rect", NULL
34913 };
34914
34915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) 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_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34919 }
34920 arg1 = reinterpret_cast< wxWindow * >(argp1);
34921 {
34922 arg2 = &temp2;
34923 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34924 }
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 {
34932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34933 }
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34941 PyObject *resultobj = 0;
34942 wxWindow *arg1 = (wxWindow *) 0 ;
34943 SwigValueWrapper<wxVisualAttributes > result;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 PyObject *swig_obj[1] ;
34947
34948 if (!args) SWIG_fail;
34949 swig_obj[0] = args;
34950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34951 if (!SWIG_IsOK(res1)) {
34952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34953 }
34954 arg1 = reinterpret_cast< wxWindow * >(argp1);
34955 {
34956 PyThreadState* __tstate = wxPyBeginAllowThreads();
34957 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34962 return resultobj;
34963 fail:
34964 return NULL;
34965 }
34966
34967
34968 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34969 PyObject *resultobj = 0;
34970 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34971 SwigValueWrapper<wxVisualAttributes > result;
34972 int val1 ;
34973 int ecode1 = 0 ;
34974 PyObject * obj0 = 0 ;
34975 char * kwnames[] = {
34976 (char *) "variant", NULL
34977 };
34978
34979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34980 if (obj0) {
34981 ecode1 = SWIG_AsVal_int(obj0, &val1);
34982 if (!SWIG_IsOK(ecode1)) {
34983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34984 }
34985 arg1 = static_cast< wxWindowVariant >(val1);
34986 }
34987 {
34988 if (!wxPyCheckForApp()) SWIG_fail;
34989 PyThreadState* __tstate = wxPyBeginAllowThreads();
34990 result = wxWindow::GetClassDefaultAttributes(arg1);
34991 wxPyEndAllowThreads(__tstate);
34992 if (PyErr_Occurred()) SWIG_fail;
34993 }
34994 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34995 return resultobj;
34996 fail:
34997 return NULL;
34998 }
34999
35000
35001 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35002 PyObject *resultobj = 0;
35003 wxWindow *arg1 = (wxWindow *) 0 ;
35004 wxColour *arg2 = 0 ;
35005 bool result;
35006 void *argp1 = 0 ;
35007 int res1 = 0 ;
35008 wxColour temp2 ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 char * kwnames[] = {
35012 (char *) "self",(char *) "colour", NULL
35013 };
35014
35015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35017 if (!SWIG_IsOK(res1)) {
35018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35019 }
35020 arg1 = reinterpret_cast< wxWindow * >(argp1);
35021 {
35022 arg2 = &temp2;
35023 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35024 }
35025 {
35026 PyThreadState* __tstate = wxPyBeginAllowThreads();
35027 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35028 wxPyEndAllowThreads(__tstate);
35029 if (PyErr_Occurred()) SWIG_fail;
35030 }
35031 {
35032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35033 }
35034 return resultobj;
35035 fail:
35036 return NULL;
35037 }
35038
35039
35040 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35041 PyObject *resultobj = 0;
35042 wxWindow *arg1 = (wxWindow *) 0 ;
35043 wxColour *arg2 = 0 ;
35044 void *argp1 = 0 ;
35045 int res1 = 0 ;
35046 wxColour temp2 ;
35047 PyObject * obj0 = 0 ;
35048 PyObject * obj1 = 0 ;
35049 char * kwnames[] = {
35050 (char *) "self",(char *) "colour", NULL
35051 };
35052
35053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35057 }
35058 arg1 = reinterpret_cast< wxWindow * >(argp1);
35059 {
35060 arg2 = &temp2;
35061 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35062 }
35063 {
35064 PyThreadState* __tstate = wxPyBeginAllowThreads();
35065 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35066 wxPyEndAllowThreads(__tstate);
35067 if (PyErr_Occurred()) SWIG_fail;
35068 }
35069 resultobj = SWIG_Py_Void();
35070 return resultobj;
35071 fail:
35072 return NULL;
35073 }
35074
35075
35076 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35077 PyObject *resultobj = 0;
35078 wxWindow *arg1 = (wxWindow *) 0 ;
35079 wxColour *arg2 = 0 ;
35080 bool result;
35081 void *argp1 = 0 ;
35082 int res1 = 0 ;
35083 wxColour temp2 ;
35084 PyObject * obj0 = 0 ;
35085 PyObject * obj1 = 0 ;
35086 char * kwnames[] = {
35087 (char *) "self",(char *) "colour", NULL
35088 };
35089
35090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35092 if (!SWIG_IsOK(res1)) {
35093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35094 }
35095 arg1 = reinterpret_cast< wxWindow * >(argp1);
35096 {
35097 arg2 = &temp2;
35098 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35099 }
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 {
35107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35108 }
35109 return resultobj;
35110 fail:
35111 return NULL;
35112 }
35113
35114
35115 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35116 PyObject *resultobj = 0;
35117 wxWindow *arg1 = (wxWindow *) 0 ;
35118 wxColour *arg2 = 0 ;
35119 void *argp1 = 0 ;
35120 int res1 = 0 ;
35121 wxColour temp2 ;
35122 PyObject * obj0 = 0 ;
35123 PyObject * obj1 = 0 ;
35124 char * kwnames[] = {
35125 (char *) "self",(char *) "colour", NULL
35126 };
35127
35128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35130 if (!SWIG_IsOK(res1)) {
35131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 {
35135 arg2 = &temp2;
35136 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35137 }
35138 {
35139 PyThreadState* __tstate = wxPyBeginAllowThreads();
35140 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35141 wxPyEndAllowThreads(__tstate);
35142 if (PyErr_Occurred()) SWIG_fail;
35143 }
35144 resultobj = SWIG_Py_Void();
35145 return resultobj;
35146 fail:
35147 return NULL;
35148 }
35149
35150
35151 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35152 PyObject *resultobj = 0;
35153 wxWindow *arg1 = (wxWindow *) 0 ;
35154 wxColour result;
35155 void *argp1 = 0 ;
35156 int res1 = 0 ;
35157 PyObject *swig_obj[1] ;
35158
35159 if (!args) SWIG_fail;
35160 swig_obj[0] = args;
35161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35162 if (!SWIG_IsOK(res1)) {
35163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35164 }
35165 arg1 = reinterpret_cast< wxWindow * >(argp1);
35166 {
35167 PyThreadState* __tstate = wxPyBeginAllowThreads();
35168 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35169 wxPyEndAllowThreads(__tstate);
35170 if (PyErr_Occurred()) SWIG_fail;
35171 }
35172 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35173 return resultobj;
35174 fail:
35175 return NULL;
35176 }
35177
35178
35179 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35180 PyObject *resultobj = 0;
35181 wxWindow *arg1 = (wxWindow *) 0 ;
35182 wxColour result;
35183 void *argp1 = 0 ;
35184 int res1 = 0 ;
35185 PyObject *swig_obj[1] ;
35186
35187 if (!args) SWIG_fail;
35188 swig_obj[0] = args;
35189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35190 if (!SWIG_IsOK(res1)) {
35191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35192 }
35193 arg1 = reinterpret_cast< wxWindow * >(argp1);
35194 {
35195 PyThreadState* __tstate = wxPyBeginAllowThreads();
35196 result = ((wxWindow const *)arg1)->GetForegroundColour();
35197 wxPyEndAllowThreads(__tstate);
35198 if (PyErr_Occurred()) SWIG_fail;
35199 }
35200 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35201 return resultobj;
35202 fail:
35203 return NULL;
35204 }
35205
35206
35207 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35208 PyObject *resultobj = 0;
35209 wxWindow *arg1 = (wxWindow *) 0 ;
35210 bool result;
35211 void *argp1 = 0 ;
35212 int res1 = 0 ;
35213 PyObject *swig_obj[1] ;
35214
35215 if (!args) SWIG_fail;
35216 swig_obj[0] = args;
35217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35218 if (!SWIG_IsOK(res1)) {
35219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35220 }
35221 arg1 = reinterpret_cast< wxWindow * >(argp1);
35222 {
35223 PyThreadState* __tstate = wxPyBeginAllowThreads();
35224 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35225 wxPyEndAllowThreads(__tstate);
35226 if (PyErr_Occurred()) SWIG_fail;
35227 }
35228 {
35229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35230 }
35231 return resultobj;
35232 fail:
35233 return NULL;
35234 }
35235
35236
35237 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35238 PyObject *resultobj = 0;
35239 wxWindow *arg1 = (wxWindow *) 0 ;
35240 bool result;
35241 void *argp1 = 0 ;
35242 int res1 = 0 ;
35243 PyObject *swig_obj[1] ;
35244
35245 if (!args) SWIG_fail;
35246 swig_obj[0] = args;
35247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35248 if (!SWIG_IsOK(res1)) {
35249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35250 }
35251 arg1 = reinterpret_cast< wxWindow * >(argp1);
35252 {
35253 PyThreadState* __tstate = wxPyBeginAllowThreads();
35254 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35255 wxPyEndAllowThreads(__tstate);
35256 if (PyErr_Occurred()) SWIG_fail;
35257 }
35258 {
35259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35260 }
35261 return resultobj;
35262 fail:
35263 return NULL;
35264 }
35265
35266
35267 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35268 PyObject *resultobj = 0;
35269 wxWindow *arg1 = (wxWindow *) 0 ;
35270 wxBackgroundStyle arg2 ;
35271 bool result;
35272 void *argp1 = 0 ;
35273 int res1 = 0 ;
35274 int val2 ;
35275 int ecode2 = 0 ;
35276 PyObject * obj0 = 0 ;
35277 PyObject * obj1 = 0 ;
35278 char * kwnames[] = {
35279 (char *) "self",(char *) "style", NULL
35280 };
35281
35282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35284 if (!SWIG_IsOK(res1)) {
35285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35286 }
35287 arg1 = reinterpret_cast< wxWindow * >(argp1);
35288 ecode2 = SWIG_AsVal_int(obj1, &val2);
35289 if (!SWIG_IsOK(ecode2)) {
35290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35291 }
35292 arg2 = static_cast< wxBackgroundStyle >(val2);
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35296 wxPyEndAllowThreads(__tstate);
35297 if (PyErr_Occurred()) SWIG_fail;
35298 }
35299 {
35300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35301 }
35302 return resultobj;
35303 fail:
35304 return NULL;
35305 }
35306
35307
35308 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35309 PyObject *resultobj = 0;
35310 wxWindow *arg1 = (wxWindow *) 0 ;
35311 wxBackgroundStyle result;
35312 void *argp1 = 0 ;
35313 int res1 = 0 ;
35314 PyObject *swig_obj[1] ;
35315
35316 if (!args) SWIG_fail;
35317 swig_obj[0] = args;
35318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35319 if (!SWIG_IsOK(res1)) {
35320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35321 }
35322 arg1 = reinterpret_cast< wxWindow * >(argp1);
35323 {
35324 PyThreadState* __tstate = wxPyBeginAllowThreads();
35325 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35326 wxPyEndAllowThreads(__tstate);
35327 if (PyErr_Occurred()) SWIG_fail;
35328 }
35329 resultobj = SWIG_From_int(static_cast< int >(result));
35330 return resultobj;
35331 fail:
35332 return NULL;
35333 }
35334
35335
35336 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35337 PyObject *resultobj = 0;
35338 wxWindow *arg1 = (wxWindow *) 0 ;
35339 bool result;
35340 void *argp1 = 0 ;
35341 int res1 = 0 ;
35342 PyObject *swig_obj[1] ;
35343
35344 if (!args) SWIG_fail;
35345 swig_obj[0] = args;
35346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35347 if (!SWIG_IsOK(res1)) {
35348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35349 }
35350 arg1 = reinterpret_cast< wxWindow * >(argp1);
35351 {
35352 PyThreadState* __tstate = wxPyBeginAllowThreads();
35353 result = (bool)(arg1)->HasTransparentBackground();
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 {
35358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35359 }
35360 return resultobj;
35361 fail:
35362 return NULL;
35363 }
35364
35365
35366 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35367 PyObject *resultobj = 0;
35368 wxWindow *arg1 = (wxWindow *) 0 ;
35369 wxCursor *arg2 = 0 ;
35370 bool result;
35371 void *argp1 = 0 ;
35372 int res1 = 0 ;
35373 void *argp2 = 0 ;
35374 int res2 = 0 ;
35375 PyObject * obj0 = 0 ;
35376 PyObject * obj1 = 0 ;
35377 char * kwnames[] = {
35378 (char *) "self",(char *) "cursor", NULL
35379 };
35380
35381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35383 if (!SWIG_IsOK(res1)) {
35384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35385 }
35386 arg1 = reinterpret_cast< wxWindow * >(argp1);
35387 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35388 if (!SWIG_IsOK(res2)) {
35389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35390 }
35391 if (!argp2) {
35392 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35393 }
35394 arg2 = reinterpret_cast< wxCursor * >(argp2);
35395 {
35396 PyThreadState* __tstate = wxPyBeginAllowThreads();
35397 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 {
35402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35403 }
35404 return resultobj;
35405 fail:
35406 return NULL;
35407 }
35408
35409
35410 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35411 PyObject *resultobj = 0;
35412 wxWindow *arg1 = (wxWindow *) 0 ;
35413 wxCursor result;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 PyObject *swig_obj[1] ;
35417
35418 if (!args) SWIG_fail;
35419 swig_obj[0] = args;
35420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35421 if (!SWIG_IsOK(res1)) {
35422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35423 }
35424 arg1 = reinterpret_cast< wxWindow * >(argp1);
35425 {
35426 PyThreadState* __tstate = wxPyBeginAllowThreads();
35427 result = (arg1)->GetCursor();
35428 wxPyEndAllowThreads(__tstate);
35429 if (PyErr_Occurred()) SWIG_fail;
35430 }
35431 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35432 return resultobj;
35433 fail:
35434 return NULL;
35435 }
35436
35437
35438 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35439 PyObject *resultobj = 0;
35440 wxWindow *arg1 = (wxWindow *) 0 ;
35441 wxFont *arg2 = 0 ;
35442 bool result;
35443 void *argp1 = 0 ;
35444 int res1 = 0 ;
35445 void *argp2 = 0 ;
35446 int res2 = 0 ;
35447 PyObject * obj0 = 0 ;
35448 PyObject * obj1 = 0 ;
35449 char * kwnames[] = {
35450 (char *) "self",(char *) "font", NULL
35451 };
35452
35453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35455 if (!SWIG_IsOK(res1)) {
35456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35457 }
35458 arg1 = reinterpret_cast< wxWindow * >(argp1);
35459 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35460 if (!SWIG_IsOK(res2)) {
35461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35462 }
35463 if (!argp2) {
35464 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35465 }
35466 arg2 = reinterpret_cast< wxFont * >(argp2);
35467 {
35468 PyThreadState* __tstate = wxPyBeginAllowThreads();
35469 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35470 wxPyEndAllowThreads(__tstate);
35471 if (PyErr_Occurred()) SWIG_fail;
35472 }
35473 {
35474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35475 }
35476 return resultobj;
35477 fail:
35478 return NULL;
35479 }
35480
35481
35482 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35483 PyObject *resultobj = 0;
35484 wxWindow *arg1 = (wxWindow *) 0 ;
35485 wxFont *arg2 = 0 ;
35486 void *argp1 = 0 ;
35487 int res1 = 0 ;
35488 void *argp2 = 0 ;
35489 int res2 = 0 ;
35490 PyObject * obj0 = 0 ;
35491 PyObject * obj1 = 0 ;
35492 char * kwnames[] = {
35493 (char *) "self",(char *) "font", NULL
35494 };
35495
35496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35503 if (!SWIG_IsOK(res2)) {
35504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35505 }
35506 if (!argp2) {
35507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35508 }
35509 arg2 = reinterpret_cast< wxFont * >(argp2);
35510 {
35511 PyThreadState* __tstate = wxPyBeginAllowThreads();
35512 (arg1)->SetOwnFont((wxFont const &)*arg2);
35513 wxPyEndAllowThreads(__tstate);
35514 if (PyErr_Occurred()) SWIG_fail;
35515 }
35516 resultobj = SWIG_Py_Void();
35517 return resultobj;
35518 fail:
35519 return NULL;
35520 }
35521
35522
35523 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35524 PyObject *resultobj = 0;
35525 wxWindow *arg1 = (wxWindow *) 0 ;
35526 wxFont result;
35527 void *argp1 = 0 ;
35528 int res1 = 0 ;
35529 PyObject *swig_obj[1] ;
35530
35531 if (!args) SWIG_fail;
35532 swig_obj[0] = args;
35533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35534 if (!SWIG_IsOK(res1)) {
35535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35536 }
35537 arg1 = reinterpret_cast< wxWindow * >(argp1);
35538 {
35539 PyThreadState* __tstate = wxPyBeginAllowThreads();
35540 result = (arg1)->GetFont();
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35552 PyObject *resultobj = 0;
35553 wxWindow *arg1 = (wxWindow *) 0 ;
35554 wxCaret *arg2 = (wxCaret *) 0 ;
35555 void *argp1 = 0 ;
35556 int res1 = 0 ;
35557 int res2 = 0 ;
35558 PyObject * obj0 = 0 ;
35559 PyObject * obj1 = 0 ;
35560 char * kwnames[] = {
35561 (char *) "self",(char *) "caret", NULL
35562 };
35563
35564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35566 if (!SWIG_IsOK(res1)) {
35567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35568 }
35569 arg1 = reinterpret_cast< wxWindow * >(argp1);
35570 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35571 if (!SWIG_IsOK(res2)) {
35572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35573 }
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 (arg1)->SetCaret(arg2);
35577 wxPyEndAllowThreads(__tstate);
35578 if (PyErr_Occurred()) SWIG_fail;
35579 }
35580 resultobj = SWIG_Py_Void();
35581 return resultobj;
35582 fail:
35583 return NULL;
35584 }
35585
35586
35587 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35588 PyObject *resultobj = 0;
35589 wxWindow *arg1 = (wxWindow *) 0 ;
35590 wxCaret *result = 0 ;
35591 void *argp1 = 0 ;
35592 int res1 = 0 ;
35593 PyObject *swig_obj[1] ;
35594
35595 if (!args) SWIG_fail;
35596 swig_obj[0] = args;
35597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35598 if (!SWIG_IsOK(res1)) {
35599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35600 }
35601 arg1 = reinterpret_cast< wxWindow * >(argp1);
35602 {
35603 PyThreadState* __tstate = wxPyBeginAllowThreads();
35604 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35605 wxPyEndAllowThreads(__tstate);
35606 if (PyErr_Occurred()) SWIG_fail;
35607 }
35608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35609 return resultobj;
35610 fail:
35611 return NULL;
35612 }
35613
35614
35615 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35616 PyObject *resultobj = 0;
35617 wxWindow *arg1 = (wxWindow *) 0 ;
35618 int result;
35619 void *argp1 = 0 ;
35620 int res1 = 0 ;
35621 PyObject *swig_obj[1] ;
35622
35623 if (!args) SWIG_fail;
35624 swig_obj[0] = args;
35625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35626 if (!SWIG_IsOK(res1)) {
35627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35628 }
35629 arg1 = reinterpret_cast< wxWindow * >(argp1);
35630 {
35631 PyThreadState* __tstate = wxPyBeginAllowThreads();
35632 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35633 wxPyEndAllowThreads(__tstate);
35634 if (PyErr_Occurred()) SWIG_fail;
35635 }
35636 resultobj = SWIG_From_int(static_cast< int >(result));
35637 return resultobj;
35638 fail:
35639 return NULL;
35640 }
35641
35642
35643 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35644 PyObject *resultobj = 0;
35645 wxWindow *arg1 = (wxWindow *) 0 ;
35646 int result;
35647 void *argp1 = 0 ;
35648 int res1 = 0 ;
35649 PyObject *swig_obj[1] ;
35650
35651 if (!args) SWIG_fail;
35652 swig_obj[0] = args;
35653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35654 if (!SWIG_IsOK(res1)) {
35655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35656 }
35657 arg1 = reinterpret_cast< wxWindow * >(argp1);
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35661 wxPyEndAllowThreads(__tstate);
35662 if (PyErr_Occurred()) SWIG_fail;
35663 }
35664 resultobj = SWIG_From_int(static_cast< int >(result));
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35672 PyObject *resultobj = 0;
35673 wxWindow *arg1 = (wxWindow *) 0 ;
35674 wxString *arg2 = 0 ;
35675 int *arg3 = (int *) 0 ;
35676 int *arg4 = (int *) 0 ;
35677 void *argp1 = 0 ;
35678 int res1 = 0 ;
35679 bool temp2 = false ;
35680 int temp3 ;
35681 int res3 = SWIG_TMPOBJ ;
35682 int temp4 ;
35683 int res4 = SWIG_TMPOBJ ;
35684 PyObject * obj0 = 0 ;
35685 PyObject * obj1 = 0 ;
35686 char * kwnames[] = {
35687 (char *) "self",(char *) "string", NULL
35688 };
35689
35690 arg3 = &temp3;
35691 arg4 = &temp4;
35692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35694 if (!SWIG_IsOK(res1)) {
35695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35696 }
35697 arg1 = reinterpret_cast< wxWindow * >(argp1);
35698 {
35699 arg2 = wxString_in_helper(obj1);
35700 if (arg2 == NULL) SWIG_fail;
35701 temp2 = true;
35702 }
35703 {
35704 PyThreadState* __tstate = wxPyBeginAllowThreads();
35705 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35706 wxPyEndAllowThreads(__tstate);
35707 if (PyErr_Occurred()) SWIG_fail;
35708 }
35709 resultobj = SWIG_Py_Void();
35710 if (SWIG_IsTmpObj(res3)) {
35711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35712 } else {
35713 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35715 }
35716 if (SWIG_IsTmpObj(res4)) {
35717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35718 } else {
35719 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35721 }
35722 {
35723 if (temp2)
35724 delete arg2;
35725 }
35726 return resultobj;
35727 fail:
35728 {
35729 if (temp2)
35730 delete arg2;
35731 }
35732 return NULL;
35733 }
35734
35735
35736 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35737 PyObject *resultobj = 0;
35738 wxWindow *arg1 = (wxWindow *) 0 ;
35739 wxString *arg2 = 0 ;
35740 int *arg3 = (int *) 0 ;
35741 int *arg4 = (int *) 0 ;
35742 int *arg5 = (int *) 0 ;
35743 int *arg6 = (int *) 0 ;
35744 wxFont *arg7 = (wxFont *) NULL ;
35745 void *argp1 = 0 ;
35746 int res1 = 0 ;
35747 bool temp2 = false ;
35748 int temp3 ;
35749 int res3 = SWIG_TMPOBJ ;
35750 int temp4 ;
35751 int res4 = SWIG_TMPOBJ ;
35752 int temp5 ;
35753 int res5 = SWIG_TMPOBJ ;
35754 int temp6 ;
35755 int res6 = SWIG_TMPOBJ ;
35756 void *argp7 = 0 ;
35757 int res7 = 0 ;
35758 PyObject * obj0 = 0 ;
35759 PyObject * obj1 = 0 ;
35760 PyObject * obj2 = 0 ;
35761 char * kwnames[] = {
35762 (char *) "self",(char *) "string",(char *) "font", NULL
35763 };
35764
35765 arg3 = &temp3;
35766 arg4 = &temp4;
35767 arg5 = &temp5;
35768 arg6 = &temp6;
35769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35771 if (!SWIG_IsOK(res1)) {
35772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35773 }
35774 arg1 = reinterpret_cast< wxWindow * >(argp1);
35775 {
35776 arg2 = wxString_in_helper(obj1);
35777 if (arg2 == NULL) SWIG_fail;
35778 temp2 = true;
35779 }
35780 if (obj2) {
35781 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35782 if (!SWIG_IsOK(res7)) {
35783 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35784 }
35785 arg7 = reinterpret_cast< wxFont * >(argp7);
35786 }
35787 {
35788 PyThreadState* __tstate = wxPyBeginAllowThreads();
35789 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35790 wxPyEndAllowThreads(__tstate);
35791 if (PyErr_Occurred()) SWIG_fail;
35792 }
35793 resultobj = SWIG_Py_Void();
35794 if (SWIG_IsTmpObj(res3)) {
35795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35796 } else {
35797 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35799 }
35800 if (SWIG_IsTmpObj(res4)) {
35801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35802 } else {
35803 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35805 }
35806 if (SWIG_IsTmpObj(res5)) {
35807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35808 } else {
35809 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35811 }
35812 if (SWIG_IsTmpObj(res6)) {
35813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35814 } else {
35815 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35817 }
35818 {
35819 if (temp2)
35820 delete arg2;
35821 }
35822 return resultobj;
35823 fail:
35824 {
35825 if (temp2)
35826 delete arg2;
35827 }
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35833 PyObject *resultobj = 0;
35834 wxWindow *arg1 = (wxWindow *) 0 ;
35835 int *arg2 = (int *) 0 ;
35836 int *arg3 = (int *) 0 ;
35837 void *argp1 = 0 ;
35838 int res1 = 0 ;
35839 int temp2 ;
35840 int res2 = 0 ;
35841 int temp3 ;
35842 int res3 = 0 ;
35843 PyObject * obj0 = 0 ;
35844 PyObject * obj1 = 0 ;
35845 PyObject * obj2 = 0 ;
35846 char * kwnames[] = {
35847 (char *) "self",(char *) "x",(char *) "y", NULL
35848 };
35849
35850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35852 if (!SWIG_IsOK(res1)) {
35853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35854 }
35855 arg1 = reinterpret_cast< wxWindow * >(argp1);
35856 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35857 int val;
35858 int ecode = SWIG_AsVal_int(obj1, &val);
35859 if (!SWIG_IsOK(ecode)) {
35860 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35861 }
35862 temp2 = static_cast< int >(val);
35863 arg2 = &temp2;
35864 res2 = SWIG_AddTmpMask(ecode);
35865 }
35866 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35867 int val;
35868 int ecode = SWIG_AsVal_int(obj2, &val);
35869 if (!SWIG_IsOK(ecode)) {
35870 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35871 }
35872 temp3 = static_cast< int >(val);
35873 arg3 = &temp3;
35874 res3 = SWIG_AddTmpMask(ecode);
35875 }
35876 {
35877 PyThreadState* __tstate = wxPyBeginAllowThreads();
35878 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35879 wxPyEndAllowThreads(__tstate);
35880 if (PyErr_Occurred()) SWIG_fail;
35881 }
35882 resultobj = SWIG_Py_Void();
35883 if (SWIG_IsTmpObj(res2)) {
35884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35885 } else {
35886 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35888 }
35889 if (SWIG_IsTmpObj(res3)) {
35890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35891 } else {
35892 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35894 }
35895 return resultobj;
35896 fail:
35897 return NULL;
35898 }
35899
35900
35901 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35902 PyObject *resultobj = 0;
35903 wxWindow *arg1 = (wxWindow *) 0 ;
35904 int *arg2 = (int *) 0 ;
35905 int *arg3 = (int *) 0 ;
35906 void *argp1 = 0 ;
35907 int res1 = 0 ;
35908 int temp2 ;
35909 int res2 = 0 ;
35910 int temp3 ;
35911 int res3 = 0 ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 PyObject * obj2 = 0 ;
35915 char * kwnames[] = {
35916 (char *) "self",(char *) "x",(char *) "y", NULL
35917 };
35918
35919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35926 int val;
35927 int ecode = SWIG_AsVal_int(obj1, &val);
35928 if (!SWIG_IsOK(ecode)) {
35929 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35930 }
35931 temp2 = static_cast< int >(val);
35932 arg2 = &temp2;
35933 res2 = SWIG_AddTmpMask(ecode);
35934 }
35935 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35936 int val;
35937 int ecode = SWIG_AsVal_int(obj2, &val);
35938 if (!SWIG_IsOK(ecode)) {
35939 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35940 }
35941 temp3 = static_cast< int >(val);
35942 arg3 = &temp3;
35943 res3 = SWIG_AddTmpMask(ecode);
35944 }
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 resultobj = SWIG_Py_Void();
35952 if (SWIG_IsTmpObj(res2)) {
35953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35954 } else {
35955 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35956 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35957 }
35958 if (SWIG_IsTmpObj(res3)) {
35959 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35960 } else {
35961 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35963 }
35964 return resultobj;
35965 fail:
35966 return NULL;
35967 }
35968
35969
35970 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35971 PyObject *resultobj = 0;
35972 wxWindow *arg1 = (wxWindow *) 0 ;
35973 wxPoint *arg2 = 0 ;
35974 wxPoint result;
35975 void *argp1 = 0 ;
35976 int res1 = 0 ;
35977 wxPoint temp2 ;
35978 PyObject * obj0 = 0 ;
35979 PyObject * obj1 = 0 ;
35980 char * kwnames[] = {
35981 (char *) "self",(char *) "pt", NULL
35982 };
35983
35984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35986 if (!SWIG_IsOK(res1)) {
35987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35988 }
35989 arg1 = reinterpret_cast< wxWindow * >(argp1);
35990 {
35991 arg2 = &temp2;
35992 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35993 }
35994 {
35995 PyThreadState* __tstate = wxPyBeginAllowThreads();
35996 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35997 wxPyEndAllowThreads(__tstate);
35998 if (PyErr_Occurred()) SWIG_fail;
35999 }
36000 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36001 return resultobj;
36002 fail:
36003 return NULL;
36004 }
36005
36006
36007 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36008 PyObject *resultobj = 0;
36009 wxWindow *arg1 = (wxWindow *) 0 ;
36010 wxPoint *arg2 = 0 ;
36011 wxPoint result;
36012 void *argp1 = 0 ;
36013 int res1 = 0 ;
36014 wxPoint temp2 ;
36015 PyObject * obj0 = 0 ;
36016 PyObject * obj1 = 0 ;
36017 char * kwnames[] = {
36018 (char *) "self",(char *) "pt", NULL
36019 };
36020
36021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36023 if (!SWIG_IsOK(res1)) {
36024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36025 }
36026 arg1 = reinterpret_cast< wxWindow * >(argp1);
36027 {
36028 arg2 = &temp2;
36029 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36030 }
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj = 0;
36046 wxWindow *arg1 = (wxWindow *) 0 ;
36047 int arg2 ;
36048 int arg3 ;
36049 wxHitTest result;
36050 void *argp1 = 0 ;
36051 int res1 = 0 ;
36052 int val2 ;
36053 int ecode2 = 0 ;
36054 int val3 ;
36055 int ecode3 = 0 ;
36056 PyObject * obj0 = 0 ;
36057 PyObject * obj1 = 0 ;
36058 PyObject * obj2 = 0 ;
36059 char * kwnames[] = {
36060 (char *) "self",(char *) "x",(char *) "y", NULL
36061 };
36062
36063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36065 if (!SWIG_IsOK(res1)) {
36066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36067 }
36068 arg1 = reinterpret_cast< wxWindow * >(argp1);
36069 ecode2 = SWIG_AsVal_int(obj1, &val2);
36070 if (!SWIG_IsOK(ecode2)) {
36071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36072 }
36073 arg2 = static_cast< int >(val2);
36074 ecode3 = SWIG_AsVal_int(obj2, &val3);
36075 if (!SWIG_IsOK(ecode3)) {
36076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36077 }
36078 arg3 = static_cast< int >(val3);
36079 {
36080 PyThreadState* __tstate = wxPyBeginAllowThreads();
36081 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36082 wxPyEndAllowThreads(__tstate);
36083 if (PyErr_Occurred()) SWIG_fail;
36084 }
36085 resultobj = SWIG_From_int(static_cast< int >(result));
36086 return resultobj;
36087 fail:
36088 return NULL;
36089 }
36090
36091
36092 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36093 PyObject *resultobj = 0;
36094 wxWindow *arg1 = (wxWindow *) 0 ;
36095 wxPoint *arg2 = 0 ;
36096 wxHitTest result;
36097 void *argp1 = 0 ;
36098 int res1 = 0 ;
36099 wxPoint temp2 ;
36100 PyObject * obj0 = 0 ;
36101 PyObject * obj1 = 0 ;
36102 char * kwnames[] = {
36103 (char *) "self",(char *) "pt", NULL
36104 };
36105
36106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36108 if (!SWIG_IsOK(res1)) {
36109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36110 }
36111 arg1 = reinterpret_cast< wxWindow * >(argp1);
36112 {
36113 arg2 = &temp2;
36114 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36115 }
36116 {
36117 PyThreadState* __tstate = wxPyBeginAllowThreads();
36118 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36119 wxPyEndAllowThreads(__tstate);
36120 if (PyErr_Occurred()) SWIG_fail;
36121 }
36122 resultobj = SWIG_From_int(static_cast< int >(result));
36123 return resultobj;
36124 fail:
36125 return NULL;
36126 }
36127
36128
36129 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36130 PyObject *resultobj = 0;
36131 wxWindow *arg1 = (wxWindow *) 0 ;
36132 long arg2 ;
36133 wxBorder result;
36134 void *argp1 = 0 ;
36135 int res1 = 0 ;
36136 long val2 ;
36137 int ecode2 = 0 ;
36138
36139 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36141 if (!SWIG_IsOK(res1)) {
36142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36143 }
36144 arg1 = reinterpret_cast< wxWindow * >(argp1);
36145 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36146 if (!SWIG_IsOK(ecode2)) {
36147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36148 }
36149 arg2 = static_cast< long >(val2);
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36153 wxPyEndAllowThreads(__tstate);
36154 if (PyErr_Occurred()) SWIG_fail;
36155 }
36156 resultobj = SWIG_From_int(static_cast< int >(result));
36157 return resultobj;
36158 fail:
36159 return NULL;
36160 }
36161
36162
36163 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36164 PyObject *resultobj = 0;
36165 wxWindow *arg1 = (wxWindow *) 0 ;
36166 wxBorder result;
36167 void *argp1 = 0 ;
36168 int res1 = 0 ;
36169
36170 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36172 if (!SWIG_IsOK(res1)) {
36173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36174 }
36175 arg1 = reinterpret_cast< wxWindow * >(argp1);
36176 {
36177 PyThreadState* __tstate = wxPyBeginAllowThreads();
36178 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36179 wxPyEndAllowThreads(__tstate);
36180 if (PyErr_Occurred()) SWIG_fail;
36181 }
36182 resultobj = SWIG_From_int(static_cast< int >(result));
36183 return resultobj;
36184 fail:
36185 return NULL;
36186 }
36187
36188
36189 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36190 int argc;
36191 PyObject *argv[3];
36192
36193 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36194 --argc;
36195 if (argc == 1) {
36196 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36197 }
36198 if (argc == 2) {
36199 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36200 }
36201
36202 fail:
36203 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36204 return NULL;
36205 }
36206
36207
36208 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36209 PyObject *resultobj = 0;
36210 wxWindow *arg1 = (wxWindow *) 0 ;
36211 long arg2 = (long) wxUPDATE_UI_NONE ;
36212 void *argp1 = 0 ;
36213 int res1 = 0 ;
36214 long val2 ;
36215 int ecode2 = 0 ;
36216 PyObject * obj0 = 0 ;
36217 PyObject * obj1 = 0 ;
36218 char * kwnames[] = {
36219 (char *) "self",(char *) "flags", NULL
36220 };
36221
36222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36224 if (!SWIG_IsOK(res1)) {
36225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36226 }
36227 arg1 = reinterpret_cast< wxWindow * >(argp1);
36228 if (obj1) {
36229 ecode2 = SWIG_AsVal_long(obj1, &val2);
36230 if (!SWIG_IsOK(ecode2)) {
36231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36232 }
36233 arg2 = static_cast< long >(val2);
36234 }
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 (arg1)->UpdateWindowUI(arg2);
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 resultobj = SWIG_Py_Void();
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36249 PyObject *resultobj = 0;
36250 wxWindow *arg1 = (wxWindow *) 0 ;
36251 wxMenu *arg2 = (wxMenu *) 0 ;
36252 int arg3 = (int) -1 ;
36253 int arg4 = (int) -1 ;
36254 bool result;
36255 void *argp1 = 0 ;
36256 int res1 = 0 ;
36257 void *argp2 = 0 ;
36258 int res2 = 0 ;
36259 int val3 ;
36260 int ecode3 = 0 ;
36261 int val4 ;
36262 int ecode4 = 0 ;
36263 PyObject * obj0 = 0 ;
36264 PyObject * obj1 = 0 ;
36265 PyObject * obj2 = 0 ;
36266 PyObject * obj3 = 0 ;
36267 char * kwnames[] = {
36268 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36269 };
36270
36271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36275 }
36276 arg1 = reinterpret_cast< wxWindow * >(argp1);
36277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36278 if (!SWIG_IsOK(res2)) {
36279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36280 }
36281 arg2 = reinterpret_cast< wxMenu * >(argp2);
36282 if (obj2) {
36283 ecode3 = SWIG_AsVal_int(obj2, &val3);
36284 if (!SWIG_IsOK(ecode3)) {
36285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36286 }
36287 arg3 = static_cast< int >(val3);
36288 }
36289 if (obj3) {
36290 ecode4 = SWIG_AsVal_int(obj3, &val4);
36291 if (!SWIG_IsOK(ecode4)) {
36292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36293 }
36294 arg4 = static_cast< int >(val4);
36295 }
36296 {
36297 PyThreadState* __tstate = wxPyBeginAllowThreads();
36298 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36299 wxPyEndAllowThreads(__tstate);
36300 if (PyErr_Occurred()) SWIG_fail;
36301 }
36302 {
36303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36304 }
36305 return resultobj;
36306 fail:
36307 return NULL;
36308 }
36309
36310
36311 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36312 PyObject *resultobj = 0;
36313 wxWindow *arg1 = (wxWindow *) 0 ;
36314 wxMenu *arg2 = (wxMenu *) 0 ;
36315 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36316 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36317 bool result;
36318 void *argp1 = 0 ;
36319 int res1 = 0 ;
36320 void *argp2 = 0 ;
36321 int res2 = 0 ;
36322 wxPoint temp3 ;
36323 PyObject * obj0 = 0 ;
36324 PyObject * obj1 = 0 ;
36325 PyObject * obj2 = 0 ;
36326 char * kwnames[] = {
36327 (char *) "self",(char *) "menu",(char *) "pos", NULL
36328 };
36329
36330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36332 if (!SWIG_IsOK(res1)) {
36333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36334 }
36335 arg1 = reinterpret_cast< wxWindow * >(argp1);
36336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36337 if (!SWIG_IsOK(res2)) {
36338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36339 }
36340 arg2 = reinterpret_cast< wxMenu * >(argp2);
36341 if (obj2) {
36342 {
36343 arg3 = &temp3;
36344 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36345 }
36346 }
36347 {
36348 PyThreadState* __tstate = wxPyBeginAllowThreads();
36349 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36350 wxPyEndAllowThreads(__tstate);
36351 if (PyErr_Occurred()) SWIG_fail;
36352 }
36353 {
36354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36355 }
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36363 PyObject *resultobj = 0;
36364 wxWindow *arg1 = (wxWindow *) 0 ;
36365 bool result;
36366 void *argp1 = 0 ;
36367 int res1 = 0 ;
36368 PyObject *swig_obj[1] ;
36369
36370 if (!args) SWIG_fail;
36371 swig_obj[0] = args;
36372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36373 if (!SWIG_IsOK(res1)) {
36374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36375 }
36376 arg1 = reinterpret_cast< wxWindow * >(argp1);
36377 {
36378 PyThreadState* __tstate = wxPyBeginAllowThreads();
36379 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 {
36384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36385 }
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36393 PyObject *resultobj = 0;
36394 wxWindow *arg1 = (wxWindow *) 0 ;
36395 long result;
36396 void *argp1 = 0 ;
36397 int res1 = 0 ;
36398 PyObject *swig_obj[1] ;
36399
36400 if (!args) SWIG_fail;
36401 swig_obj[0] = args;
36402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36403 if (!SWIG_IsOK(res1)) {
36404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36405 }
36406 arg1 = reinterpret_cast< wxWindow * >(argp1);
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 result = (long)wxWindow_GetHandle(arg1);
36410 wxPyEndAllowThreads(__tstate);
36411 if (PyErr_Occurred()) SWIG_fail;
36412 }
36413 resultobj = SWIG_From_long(static_cast< long >(result));
36414 return resultobj;
36415 fail:
36416 return NULL;
36417 }
36418
36419
36420 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36421 PyObject *resultobj = 0;
36422 wxWindow *arg1 = (wxWindow *) 0 ;
36423 long arg2 ;
36424 void *argp1 = 0 ;
36425 int res1 = 0 ;
36426 long val2 ;
36427 int ecode2 = 0 ;
36428 PyObject * obj0 = 0 ;
36429 PyObject * obj1 = 0 ;
36430 char * kwnames[] = {
36431 (char *) "self",(char *) "handle", NULL
36432 };
36433
36434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36436 if (!SWIG_IsOK(res1)) {
36437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36438 }
36439 arg1 = reinterpret_cast< wxWindow * >(argp1);
36440 ecode2 = SWIG_AsVal_long(obj1, &val2);
36441 if (!SWIG_IsOK(ecode2)) {
36442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36443 }
36444 arg2 = static_cast< long >(val2);
36445 {
36446 PyThreadState* __tstate = wxPyBeginAllowThreads();
36447 wxWindow_AssociateHandle(arg1,arg2);
36448 wxPyEndAllowThreads(__tstate);
36449 if (PyErr_Occurred()) SWIG_fail;
36450 }
36451 resultobj = SWIG_Py_Void();
36452 return resultobj;
36453 fail:
36454 return NULL;
36455 }
36456
36457
36458 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36459 PyObject *resultobj = 0;
36460 wxWindow *arg1 = (wxWindow *) 0 ;
36461 void *argp1 = 0 ;
36462 int res1 = 0 ;
36463 PyObject *swig_obj[1] ;
36464
36465 if (!args) SWIG_fail;
36466 swig_obj[0] = args;
36467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36468 if (!SWIG_IsOK(res1)) {
36469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36470 }
36471 arg1 = reinterpret_cast< wxWindow * >(argp1);
36472 {
36473 PyThreadState* __tstate = wxPyBeginAllowThreads();
36474 (arg1)->DissociateHandle();
36475 wxPyEndAllowThreads(__tstate);
36476 if (PyErr_Occurred()) SWIG_fail;
36477 }
36478 resultobj = SWIG_Py_Void();
36479 return resultobj;
36480 fail:
36481 return NULL;
36482 }
36483
36484
36485 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36486 PyObject *resultobj = 0;
36487 wxWindow *arg1 = (wxWindow *) 0 ;
36488 int arg2 ;
36489 bool result;
36490 void *argp1 = 0 ;
36491 int res1 = 0 ;
36492 int val2 ;
36493 int ecode2 = 0 ;
36494 PyObject * obj0 = 0 ;
36495 PyObject * obj1 = 0 ;
36496 char * kwnames[] = {
36497 (char *) "self",(char *) "orient", NULL
36498 };
36499
36500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36502 if (!SWIG_IsOK(res1)) {
36503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36504 }
36505 arg1 = reinterpret_cast< wxWindow * >(argp1);
36506 ecode2 = SWIG_AsVal_int(obj1, &val2);
36507 if (!SWIG_IsOK(ecode2)) {
36508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36509 }
36510 arg2 = static_cast< int >(val2);
36511 {
36512 PyThreadState* __tstate = wxPyBeginAllowThreads();
36513 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36514 wxPyEndAllowThreads(__tstate);
36515 if (PyErr_Occurred()) SWIG_fail;
36516 }
36517 {
36518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36519 }
36520 return resultobj;
36521 fail:
36522 return NULL;
36523 }
36524
36525
36526 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36527 PyObject *resultobj = 0;
36528 wxWindow *arg1 = (wxWindow *) 0 ;
36529 int arg2 ;
36530 int arg3 ;
36531 int arg4 ;
36532 int arg5 ;
36533 bool arg6 = (bool) true ;
36534 void *argp1 = 0 ;
36535 int res1 = 0 ;
36536 int val2 ;
36537 int ecode2 = 0 ;
36538 int val3 ;
36539 int ecode3 = 0 ;
36540 int val4 ;
36541 int ecode4 = 0 ;
36542 int val5 ;
36543 int ecode5 = 0 ;
36544 bool val6 ;
36545 int ecode6 = 0 ;
36546 PyObject * obj0 = 0 ;
36547 PyObject * obj1 = 0 ;
36548 PyObject * obj2 = 0 ;
36549 PyObject * obj3 = 0 ;
36550 PyObject * obj4 = 0 ;
36551 PyObject * obj5 = 0 ;
36552 char * kwnames[] = {
36553 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36554 };
36555
36556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36558 if (!SWIG_IsOK(res1)) {
36559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36560 }
36561 arg1 = reinterpret_cast< wxWindow * >(argp1);
36562 ecode2 = SWIG_AsVal_int(obj1, &val2);
36563 if (!SWIG_IsOK(ecode2)) {
36564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36565 }
36566 arg2 = static_cast< int >(val2);
36567 ecode3 = SWIG_AsVal_int(obj2, &val3);
36568 if (!SWIG_IsOK(ecode3)) {
36569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36570 }
36571 arg3 = static_cast< int >(val3);
36572 ecode4 = SWIG_AsVal_int(obj3, &val4);
36573 if (!SWIG_IsOK(ecode4)) {
36574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36575 }
36576 arg4 = static_cast< int >(val4);
36577 ecode5 = SWIG_AsVal_int(obj4, &val5);
36578 if (!SWIG_IsOK(ecode5)) {
36579 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36580 }
36581 arg5 = static_cast< int >(val5);
36582 if (obj5) {
36583 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36584 if (!SWIG_IsOK(ecode6)) {
36585 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36586 }
36587 arg6 = static_cast< bool >(val6);
36588 }
36589 {
36590 PyThreadState* __tstate = wxPyBeginAllowThreads();
36591 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36592 wxPyEndAllowThreads(__tstate);
36593 if (PyErr_Occurred()) SWIG_fail;
36594 }
36595 resultobj = SWIG_Py_Void();
36596 return resultobj;
36597 fail:
36598 return NULL;
36599 }
36600
36601
36602 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36603 PyObject *resultobj = 0;
36604 wxWindow *arg1 = (wxWindow *) 0 ;
36605 int arg2 ;
36606 int arg3 ;
36607 bool arg4 = (bool) true ;
36608 void *argp1 = 0 ;
36609 int res1 = 0 ;
36610 int val2 ;
36611 int ecode2 = 0 ;
36612 int val3 ;
36613 int ecode3 = 0 ;
36614 bool val4 ;
36615 int ecode4 = 0 ;
36616 PyObject * obj0 = 0 ;
36617 PyObject * obj1 = 0 ;
36618 PyObject * obj2 = 0 ;
36619 PyObject * obj3 = 0 ;
36620 char * kwnames[] = {
36621 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36622 };
36623
36624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36626 if (!SWIG_IsOK(res1)) {
36627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36628 }
36629 arg1 = reinterpret_cast< wxWindow * >(argp1);
36630 ecode2 = SWIG_AsVal_int(obj1, &val2);
36631 if (!SWIG_IsOK(ecode2)) {
36632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36633 }
36634 arg2 = static_cast< int >(val2);
36635 ecode3 = SWIG_AsVal_int(obj2, &val3);
36636 if (!SWIG_IsOK(ecode3)) {
36637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36638 }
36639 arg3 = static_cast< int >(val3);
36640 if (obj3) {
36641 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36642 if (!SWIG_IsOK(ecode4)) {
36643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36644 }
36645 arg4 = static_cast< bool >(val4);
36646 }
36647 {
36648 PyThreadState* __tstate = wxPyBeginAllowThreads();
36649 (arg1)->SetScrollPos(arg2,arg3,arg4);
36650 wxPyEndAllowThreads(__tstate);
36651 if (PyErr_Occurred()) SWIG_fail;
36652 }
36653 resultobj = SWIG_Py_Void();
36654 return resultobj;
36655 fail:
36656 return NULL;
36657 }
36658
36659
36660 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36661 PyObject *resultobj = 0;
36662 wxWindow *arg1 = (wxWindow *) 0 ;
36663 int arg2 ;
36664 int result;
36665 void *argp1 = 0 ;
36666 int res1 = 0 ;
36667 int val2 ;
36668 int ecode2 = 0 ;
36669 PyObject * obj0 = 0 ;
36670 PyObject * obj1 = 0 ;
36671 char * kwnames[] = {
36672 (char *) "self",(char *) "orientation", NULL
36673 };
36674
36675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36677 if (!SWIG_IsOK(res1)) {
36678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36679 }
36680 arg1 = reinterpret_cast< wxWindow * >(argp1);
36681 ecode2 = SWIG_AsVal_int(obj1, &val2);
36682 if (!SWIG_IsOK(ecode2)) {
36683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36684 }
36685 arg2 = static_cast< int >(val2);
36686 {
36687 PyThreadState* __tstate = wxPyBeginAllowThreads();
36688 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36689 wxPyEndAllowThreads(__tstate);
36690 if (PyErr_Occurred()) SWIG_fail;
36691 }
36692 resultobj = SWIG_From_int(static_cast< int >(result));
36693 return resultobj;
36694 fail:
36695 return NULL;
36696 }
36697
36698
36699 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36700 PyObject *resultobj = 0;
36701 wxWindow *arg1 = (wxWindow *) 0 ;
36702 int arg2 ;
36703 int result;
36704 void *argp1 = 0 ;
36705 int res1 = 0 ;
36706 int val2 ;
36707 int ecode2 = 0 ;
36708 PyObject * obj0 = 0 ;
36709 PyObject * obj1 = 0 ;
36710 char * kwnames[] = {
36711 (char *) "self",(char *) "orientation", NULL
36712 };
36713
36714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36716 if (!SWIG_IsOK(res1)) {
36717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36718 }
36719 arg1 = reinterpret_cast< wxWindow * >(argp1);
36720 ecode2 = SWIG_AsVal_int(obj1, &val2);
36721 if (!SWIG_IsOK(ecode2)) {
36722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36723 }
36724 arg2 = static_cast< int >(val2);
36725 {
36726 PyThreadState* __tstate = wxPyBeginAllowThreads();
36727 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36728 wxPyEndAllowThreads(__tstate);
36729 if (PyErr_Occurred()) SWIG_fail;
36730 }
36731 resultobj = SWIG_From_int(static_cast< int >(result));
36732 return resultobj;
36733 fail:
36734 return NULL;
36735 }
36736
36737
36738 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36739 PyObject *resultobj = 0;
36740 wxWindow *arg1 = (wxWindow *) 0 ;
36741 int arg2 ;
36742 int result;
36743 void *argp1 = 0 ;
36744 int res1 = 0 ;
36745 int val2 ;
36746 int ecode2 = 0 ;
36747 PyObject * obj0 = 0 ;
36748 PyObject * obj1 = 0 ;
36749 char * kwnames[] = {
36750 (char *) "self",(char *) "orientation", NULL
36751 };
36752
36753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36755 if (!SWIG_IsOK(res1)) {
36756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36757 }
36758 arg1 = reinterpret_cast< wxWindow * >(argp1);
36759 ecode2 = SWIG_AsVal_int(obj1, &val2);
36760 if (!SWIG_IsOK(ecode2)) {
36761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36762 }
36763 arg2 = static_cast< int >(val2);
36764 {
36765 PyThreadState* __tstate = wxPyBeginAllowThreads();
36766 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36767 wxPyEndAllowThreads(__tstate);
36768 if (PyErr_Occurred()) SWIG_fail;
36769 }
36770 resultobj = SWIG_From_int(static_cast< int >(result));
36771 return resultobj;
36772 fail:
36773 return NULL;
36774 }
36775
36776
36777 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36778 PyObject *resultobj = 0;
36779 wxWindow *arg1 = (wxWindow *) 0 ;
36780 int arg2 ;
36781 int arg3 ;
36782 wxRect *arg4 = (wxRect *) NULL ;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 int val2 ;
36786 int ecode2 = 0 ;
36787 int val3 ;
36788 int ecode3 = 0 ;
36789 void *argp4 = 0 ;
36790 int res4 = 0 ;
36791 PyObject * obj0 = 0 ;
36792 PyObject * obj1 = 0 ;
36793 PyObject * obj2 = 0 ;
36794 PyObject * obj3 = 0 ;
36795 char * kwnames[] = {
36796 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36797 };
36798
36799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36801 if (!SWIG_IsOK(res1)) {
36802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36803 }
36804 arg1 = reinterpret_cast< wxWindow * >(argp1);
36805 ecode2 = SWIG_AsVal_int(obj1, &val2);
36806 if (!SWIG_IsOK(ecode2)) {
36807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36808 }
36809 arg2 = static_cast< int >(val2);
36810 ecode3 = SWIG_AsVal_int(obj2, &val3);
36811 if (!SWIG_IsOK(ecode3)) {
36812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36813 }
36814 arg3 = static_cast< int >(val3);
36815 if (obj3) {
36816 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36817 if (!SWIG_IsOK(res4)) {
36818 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36819 }
36820 arg4 = reinterpret_cast< wxRect * >(argp4);
36821 }
36822 {
36823 PyThreadState* __tstate = wxPyBeginAllowThreads();
36824 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36825 wxPyEndAllowThreads(__tstate);
36826 if (PyErr_Occurred()) SWIG_fail;
36827 }
36828 resultobj = SWIG_Py_Void();
36829 return resultobj;
36830 fail:
36831 return NULL;
36832 }
36833
36834
36835 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36836 PyObject *resultobj = 0;
36837 wxWindow *arg1 = (wxWindow *) 0 ;
36838 int arg2 ;
36839 bool result;
36840 void *argp1 = 0 ;
36841 int res1 = 0 ;
36842 int val2 ;
36843 int ecode2 = 0 ;
36844 PyObject * obj0 = 0 ;
36845 PyObject * obj1 = 0 ;
36846 char * kwnames[] = {
36847 (char *) "self",(char *) "lines", NULL
36848 };
36849
36850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36852 if (!SWIG_IsOK(res1)) {
36853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36854 }
36855 arg1 = reinterpret_cast< wxWindow * >(argp1);
36856 ecode2 = SWIG_AsVal_int(obj1, &val2);
36857 if (!SWIG_IsOK(ecode2)) {
36858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36859 }
36860 arg2 = static_cast< int >(val2);
36861 {
36862 PyThreadState* __tstate = wxPyBeginAllowThreads();
36863 result = (bool)(arg1)->ScrollLines(arg2);
36864 wxPyEndAllowThreads(__tstate);
36865 if (PyErr_Occurred()) SWIG_fail;
36866 }
36867 {
36868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36869 }
36870 return resultobj;
36871 fail:
36872 return NULL;
36873 }
36874
36875
36876 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36877 PyObject *resultobj = 0;
36878 wxWindow *arg1 = (wxWindow *) 0 ;
36879 int arg2 ;
36880 bool result;
36881 void *argp1 = 0 ;
36882 int res1 = 0 ;
36883 int val2 ;
36884 int ecode2 = 0 ;
36885 PyObject * obj0 = 0 ;
36886 PyObject * obj1 = 0 ;
36887 char * kwnames[] = {
36888 (char *) "self",(char *) "pages", NULL
36889 };
36890
36891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36893 if (!SWIG_IsOK(res1)) {
36894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36895 }
36896 arg1 = reinterpret_cast< wxWindow * >(argp1);
36897 ecode2 = SWIG_AsVal_int(obj1, &val2);
36898 if (!SWIG_IsOK(ecode2)) {
36899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36900 }
36901 arg2 = static_cast< int >(val2);
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 result = (bool)(arg1)->ScrollPages(arg2);
36905 wxPyEndAllowThreads(__tstate);
36906 if (PyErr_Occurred()) SWIG_fail;
36907 }
36908 {
36909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36910 }
36911 return resultobj;
36912 fail:
36913 return NULL;
36914 }
36915
36916
36917 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36918 PyObject *resultobj = 0;
36919 wxWindow *arg1 = (wxWindow *) 0 ;
36920 bool result;
36921 void *argp1 = 0 ;
36922 int res1 = 0 ;
36923 PyObject *swig_obj[1] ;
36924
36925 if (!args) SWIG_fail;
36926 swig_obj[0] = args;
36927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36928 if (!SWIG_IsOK(res1)) {
36929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36930 }
36931 arg1 = reinterpret_cast< wxWindow * >(argp1);
36932 {
36933 PyThreadState* __tstate = wxPyBeginAllowThreads();
36934 result = (bool)(arg1)->LineUp();
36935 wxPyEndAllowThreads(__tstate);
36936 if (PyErr_Occurred()) SWIG_fail;
36937 }
36938 {
36939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36940 }
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36948 PyObject *resultobj = 0;
36949 wxWindow *arg1 = (wxWindow *) 0 ;
36950 bool result;
36951 void *argp1 = 0 ;
36952 int res1 = 0 ;
36953 PyObject *swig_obj[1] ;
36954
36955 if (!args) SWIG_fail;
36956 swig_obj[0] = args;
36957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36958 if (!SWIG_IsOK(res1)) {
36959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36960 }
36961 arg1 = reinterpret_cast< wxWindow * >(argp1);
36962 {
36963 PyThreadState* __tstate = wxPyBeginAllowThreads();
36964 result = (bool)(arg1)->LineDown();
36965 wxPyEndAllowThreads(__tstate);
36966 if (PyErr_Occurred()) SWIG_fail;
36967 }
36968 {
36969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36970 }
36971 return resultobj;
36972 fail:
36973 return NULL;
36974 }
36975
36976
36977 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36978 PyObject *resultobj = 0;
36979 wxWindow *arg1 = (wxWindow *) 0 ;
36980 bool result;
36981 void *argp1 = 0 ;
36982 int res1 = 0 ;
36983 PyObject *swig_obj[1] ;
36984
36985 if (!args) SWIG_fail;
36986 swig_obj[0] = args;
36987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36988 if (!SWIG_IsOK(res1)) {
36989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36990 }
36991 arg1 = reinterpret_cast< wxWindow * >(argp1);
36992 {
36993 PyThreadState* __tstate = wxPyBeginAllowThreads();
36994 result = (bool)(arg1)->PageUp();
36995 wxPyEndAllowThreads(__tstate);
36996 if (PyErr_Occurred()) SWIG_fail;
36997 }
36998 {
36999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37000 }
37001 return resultobj;
37002 fail:
37003 return NULL;
37004 }
37005
37006
37007 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37008 PyObject *resultobj = 0;
37009 wxWindow *arg1 = (wxWindow *) 0 ;
37010 bool result;
37011 void *argp1 = 0 ;
37012 int res1 = 0 ;
37013 PyObject *swig_obj[1] ;
37014
37015 if (!args) SWIG_fail;
37016 swig_obj[0] = args;
37017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37018 if (!SWIG_IsOK(res1)) {
37019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37020 }
37021 arg1 = reinterpret_cast< wxWindow * >(argp1);
37022 {
37023 PyThreadState* __tstate = wxPyBeginAllowThreads();
37024 result = (bool)(arg1)->PageDown();
37025 wxPyEndAllowThreads(__tstate);
37026 if (PyErr_Occurred()) SWIG_fail;
37027 }
37028 {
37029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37030 }
37031 return resultobj;
37032 fail:
37033 return NULL;
37034 }
37035
37036
37037 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37038 PyObject *resultobj = 0;
37039 wxWindow *arg1 = (wxWindow *) 0 ;
37040 wxString *arg2 = 0 ;
37041 void *argp1 = 0 ;
37042 int res1 = 0 ;
37043 bool temp2 = false ;
37044 PyObject * obj0 = 0 ;
37045 PyObject * obj1 = 0 ;
37046 char * kwnames[] = {
37047 (char *) "self",(char *) "text", NULL
37048 };
37049
37050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37052 if (!SWIG_IsOK(res1)) {
37053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37054 }
37055 arg1 = reinterpret_cast< wxWindow * >(argp1);
37056 {
37057 arg2 = wxString_in_helper(obj1);
37058 if (arg2 == NULL) SWIG_fail;
37059 temp2 = true;
37060 }
37061 {
37062 PyThreadState* __tstate = wxPyBeginAllowThreads();
37063 (arg1)->SetHelpText((wxString const &)*arg2);
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 resultobj = SWIG_Py_Void();
37068 {
37069 if (temp2)
37070 delete arg2;
37071 }
37072 return resultobj;
37073 fail:
37074 {
37075 if (temp2)
37076 delete arg2;
37077 }
37078 return NULL;
37079 }
37080
37081
37082 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37083 PyObject *resultobj = 0;
37084 wxWindow *arg1 = (wxWindow *) 0 ;
37085 wxString *arg2 = 0 ;
37086 void *argp1 = 0 ;
37087 int res1 = 0 ;
37088 bool temp2 = false ;
37089 PyObject * obj0 = 0 ;
37090 PyObject * obj1 = 0 ;
37091 char * kwnames[] = {
37092 (char *) "self",(char *) "text", NULL
37093 };
37094
37095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37097 if (!SWIG_IsOK(res1)) {
37098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37099 }
37100 arg1 = reinterpret_cast< wxWindow * >(argp1);
37101 {
37102 arg2 = wxString_in_helper(obj1);
37103 if (arg2 == NULL) SWIG_fail;
37104 temp2 = true;
37105 }
37106 {
37107 PyThreadState* __tstate = wxPyBeginAllowThreads();
37108 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37109 wxPyEndAllowThreads(__tstate);
37110 if (PyErr_Occurred()) SWIG_fail;
37111 }
37112 resultobj = SWIG_Py_Void();
37113 {
37114 if (temp2)
37115 delete arg2;
37116 }
37117 return resultobj;
37118 fail:
37119 {
37120 if (temp2)
37121 delete arg2;
37122 }
37123 return NULL;
37124 }
37125
37126
37127 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37128 PyObject *resultobj = 0;
37129 wxWindow *arg1 = (wxWindow *) 0 ;
37130 wxPoint *arg2 = 0 ;
37131 wxHelpEvent::Origin arg3 ;
37132 wxString result;
37133 void *argp1 = 0 ;
37134 int res1 = 0 ;
37135 wxPoint temp2 ;
37136 void *argp3 ;
37137 int res3 = 0 ;
37138 PyObject * obj0 = 0 ;
37139 PyObject * obj1 = 0 ;
37140 PyObject * obj2 = 0 ;
37141 char * kwnames[] = {
37142 (char *) "self",(char *) "pt",(char *) "origin", NULL
37143 };
37144
37145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37147 if (!SWIG_IsOK(res1)) {
37148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37149 }
37150 arg1 = reinterpret_cast< wxWindow * >(argp1);
37151 {
37152 arg2 = &temp2;
37153 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37154 }
37155 {
37156 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37157 if (!SWIG_IsOK(res3)) {
37158 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37159 }
37160 if (!argp3) {
37161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37162 } else {
37163 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37164 arg3 = *temp;
37165 if (SWIG_IsNewObj(res3)) delete temp;
37166 }
37167 }
37168 {
37169 PyThreadState* __tstate = wxPyBeginAllowThreads();
37170 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37171 wxPyEndAllowThreads(__tstate);
37172 if (PyErr_Occurred()) SWIG_fail;
37173 }
37174 {
37175 #if wxUSE_UNICODE
37176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37177 #else
37178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37179 #endif
37180 }
37181 return resultobj;
37182 fail:
37183 return NULL;
37184 }
37185
37186
37187 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37188 PyObject *resultobj = 0;
37189 wxWindow *arg1 = (wxWindow *) 0 ;
37190 wxString result;
37191 void *argp1 = 0 ;
37192 int res1 = 0 ;
37193 PyObject *swig_obj[1] ;
37194
37195 if (!args) SWIG_fail;
37196 swig_obj[0] = args;
37197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37198 if (!SWIG_IsOK(res1)) {
37199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37200 }
37201 arg1 = reinterpret_cast< wxWindow * >(argp1);
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = ((wxWindow const *)arg1)->GetHelpText();
37205 wxPyEndAllowThreads(__tstate);
37206 if (PyErr_Occurred()) SWIG_fail;
37207 }
37208 {
37209 #if wxUSE_UNICODE
37210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37211 #else
37212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37213 #endif
37214 }
37215 return resultobj;
37216 fail:
37217 return NULL;
37218 }
37219
37220
37221 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37222 PyObject *resultobj = 0;
37223 wxWindow *arg1 = (wxWindow *) 0 ;
37224 wxString *arg2 = 0 ;
37225 void *argp1 = 0 ;
37226 int res1 = 0 ;
37227 bool temp2 = false ;
37228 PyObject * obj0 = 0 ;
37229 PyObject * obj1 = 0 ;
37230 char * kwnames[] = {
37231 (char *) "self",(char *) "tip", NULL
37232 };
37233
37234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37236 if (!SWIG_IsOK(res1)) {
37237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37238 }
37239 arg1 = reinterpret_cast< wxWindow * >(argp1);
37240 {
37241 arg2 = wxString_in_helper(obj1);
37242 if (arg2 == NULL) SWIG_fail;
37243 temp2 = true;
37244 }
37245 {
37246 PyThreadState* __tstate = wxPyBeginAllowThreads();
37247 (arg1)->SetToolTip((wxString const &)*arg2);
37248 wxPyEndAllowThreads(__tstate);
37249 if (PyErr_Occurred()) SWIG_fail;
37250 }
37251 resultobj = SWIG_Py_Void();
37252 {
37253 if (temp2)
37254 delete arg2;
37255 }
37256 return resultobj;
37257 fail:
37258 {
37259 if (temp2)
37260 delete arg2;
37261 }
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37267 PyObject *resultobj = 0;
37268 wxWindow *arg1 = (wxWindow *) 0 ;
37269 wxToolTip *arg2 = (wxToolTip *) 0 ;
37270 void *argp1 = 0 ;
37271 int res1 = 0 ;
37272 int res2 = 0 ;
37273 PyObject * obj0 = 0 ;
37274 PyObject * obj1 = 0 ;
37275 char * kwnames[] = {
37276 (char *) "self",(char *) "tip", NULL
37277 };
37278
37279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37281 if (!SWIG_IsOK(res1)) {
37282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37283 }
37284 arg1 = reinterpret_cast< wxWindow * >(argp1);
37285 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37286 if (!SWIG_IsOK(res2)) {
37287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37288 }
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 (arg1)->SetToolTip(arg2);
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 resultobj = SWIG_Py_Void();
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 wxToolTip *result = 0 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 PyObject *swig_obj[1] ;
37309
37310 if (!args) SWIG_fail;
37311 swig_obj[0] = args;
37312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37313 if (!SWIG_IsOK(res1)) {
37314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37315 }
37316 arg1 = reinterpret_cast< wxWindow * >(argp1);
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37320 wxPyEndAllowThreads(__tstate);
37321 if (PyErr_Occurred()) SWIG_fail;
37322 }
37323 {
37324 resultobj = wxPyMake_wxObject(result, (bool)0);
37325 }
37326 return resultobj;
37327 fail:
37328 return NULL;
37329 }
37330
37331
37332 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37333 PyObject *resultobj = 0;
37334 wxWindow *arg1 = (wxWindow *) 0 ;
37335 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37336 void *argp1 = 0 ;
37337 int res1 = 0 ;
37338 int res2 = 0 ;
37339 PyObject * obj0 = 0 ;
37340 PyObject * obj1 = 0 ;
37341 char * kwnames[] = {
37342 (char *) "self",(char *) "dropTarget", NULL
37343 };
37344
37345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37347 if (!SWIG_IsOK(res1)) {
37348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37349 }
37350 arg1 = reinterpret_cast< wxWindow * >(argp1);
37351 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37352 if (!SWIG_IsOK(res2)) {
37353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37354 }
37355 {
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 (arg1)->SetDropTarget(arg2);
37358 wxPyEndAllowThreads(__tstate);
37359 if (PyErr_Occurred()) SWIG_fail;
37360 }
37361 resultobj = SWIG_Py_Void();
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37369 PyObject *resultobj = 0;
37370 wxWindow *arg1 = (wxWindow *) 0 ;
37371 wxPyDropTarget *result = 0 ;
37372 void *argp1 = 0 ;
37373 int res1 = 0 ;
37374 PyObject *swig_obj[1] ;
37375
37376 if (!args) SWIG_fail;
37377 swig_obj[0] = args;
37378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37379 if (!SWIG_IsOK(res1)) {
37380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37381 }
37382 arg1 = reinterpret_cast< wxWindow * >(argp1);
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37397 PyObject *resultobj = 0;
37398 wxWindow *arg1 = (wxWindow *) 0 ;
37399 bool arg2 ;
37400 void *argp1 = 0 ;
37401 int res1 = 0 ;
37402 bool val2 ;
37403 int ecode2 = 0 ;
37404 PyObject * obj0 = 0 ;
37405 PyObject * obj1 = 0 ;
37406 char * kwnames[] = {
37407 (char *) "self",(char *) "accept", NULL
37408 };
37409
37410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37412 if (!SWIG_IsOK(res1)) {
37413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37414 }
37415 arg1 = reinterpret_cast< wxWindow * >(argp1);
37416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37417 if (!SWIG_IsOK(ecode2)) {
37418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37419 }
37420 arg2 = static_cast< bool >(val2);
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 wxWindow_DragAcceptFiles(arg1,arg2);
37424 wxPyEndAllowThreads(__tstate);
37425 if (PyErr_Occurred()) SWIG_fail;
37426 }
37427 resultobj = SWIG_Py_Void();
37428 return resultobj;
37429 fail:
37430 return NULL;
37431 }
37432
37433
37434 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37435 PyObject *resultobj = 0;
37436 wxWindow *arg1 = (wxWindow *) 0 ;
37437 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37438 void *argp1 = 0 ;
37439 int res1 = 0 ;
37440 int res2 = 0 ;
37441 PyObject * obj0 = 0 ;
37442 PyObject * obj1 = 0 ;
37443 char * kwnames[] = {
37444 (char *) "self",(char *) "constraints", NULL
37445 };
37446
37447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37449 if (!SWIG_IsOK(res1)) {
37450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37451 }
37452 arg1 = reinterpret_cast< wxWindow * >(argp1);
37453 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37454 if (!SWIG_IsOK(res2)) {
37455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37456 }
37457 {
37458 PyThreadState* __tstate = wxPyBeginAllowThreads();
37459 (arg1)->SetConstraints(arg2);
37460 wxPyEndAllowThreads(__tstate);
37461 if (PyErr_Occurred()) SWIG_fail;
37462 }
37463 resultobj = SWIG_Py_Void();
37464 return resultobj;
37465 fail:
37466 return NULL;
37467 }
37468
37469
37470 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37471 PyObject *resultobj = 0;
37472 wxWindow *arg1 = (wxWindow *) 0 ;
37473 wxLayoutConstraints *result = 0 ;
37474 void *argp1 = 0 ;
37475 int res1 = 0 ;
37476 PyObject *swig_obj[1] ;
37477
37478 if (!args) SWIG_fail;
37479 swig_obj[0] = args;
37480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37481 if (!SWIG_IsOK(res1)) {
37482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37483 }
37484 arg1 = reinterpret_cast< wxWindow * >(argp1);
37485 {
37486 PyThreadState* __tstate = wxPyBeginAllowThreads();
37487 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37488 wxPyEndAllowThreads(__tstate);
37489 if (PyErr_Occurred()) SWIG_fail;
37490 }
37491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37492 return resultobj;
37493 fail:
37494 return NULL;
37495 }
37496
37497
37498 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37499 PyObject *resultobj = 0;
37500 wxWindow *arg1 = (wxWindow *) 0 ;
37501 bool arg2 ;
37502 void *argp1 = 0 ;
37503 int res1 = 0 ;
37504 bool val2 ;
37505 int ecode2 = 0 ;
37506 PyObject * obj0 = 0 ;
37507 PyObject * obj1 = 0 ;
37508 char * kwnames[] = {
37509 (char *) "self",(char *) "autoLayout", NULL
37510 };
37511
37512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37514 if (!SWIG_IsOK(res1)) {
37515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37516 }
37517 arg1 = reinterpret_cast< wxWindow * >(argp1);
37518 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37519 if (!SWIG_IsOK(ecode2)) {
37520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37521 }
37522 arg2 = static_cast< bool >(val2);
37523 {
37524 PyThreadState* __tstate = wxPyBeginAllowThreads();
37525 (arg1)->SetAutoLayout(arg2);
37526 wxPyEndAllowThreads(__tstate);
37527 if (PyErr_Occurred()) SWIG_fail;
37528 }
37529 resultobj = SWIG_Py_Void();
37530 return resultobj;
37531 fail:
37532 return NULL;
37533 }
37534
37535
37536 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37537 PyObject *resultobj = 0;
37538 wxWindow *arg1 = (wxWindow *) 0 ;
37539 bool result;
37540 void *argp1 = 0 ;
37541 int res1 = 0 ;
37542 PyObject *swig_obj[1] ;
37543
37544 if (!args) SWIG_fail;
37545 swig_obj[0] = args;
37546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37547 if (!SWIG_IsOK(res1)) {
37548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37549 }
37550 arg1 = reinterpret_cast< wxWindow * >(argp1);
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37554 wxPyEndAllowThreads(__tstate);
37555 if (PyErr_Occurred()) SWIG_fail;
37556 }
37557 {
37558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37559 }
37560 return resultobj;
37561 fail:
37562 return NULL;
37563 }
37564
37565
37566 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37567 PyObject *resultobj = 0;
37568 wxWindow *arg1 = (wxWindow *) 0 ;
37569 bool result;
37570 void *argp1 = 0 ;
37571 int res1 = 0 ;
37572 PyObject *swig_obj[1] ;
37573
37574 if (!args) SWIG_fail;
37575 swig_obj[0] = args;
37576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37577 if (!SWIG_IsOK(res1)) {
37578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37579 }
37580 arg1 = reinterpret_cast< wxWindow * >(argp1);
37581 {
37582 PyThreadState* __tstate = wxPyBeginAllowThreads();
37583 result = (bool)(arg1)->Layout();
37584 wxPyEndAllowThreads(__tstate);
37585 if (PyErr_Occurred()) SWIG_fail;
37586 }
37587 {
37588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37589 }
37590 return resultobj;
37591 fail:
37592 return NULL;
37593 }
37594
37595
37596 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37597 PyObject *resultobj = 0;
37598 wxWindow *arg1 = (wxWindow *) 0 ;
37599 wxSizer *arg2 = (wxSizer *) 0 ;
37600 bool arg3 = (bool) true ;
37601 void *argp1 = 0 ;
37602 int res1 = 0 ;
37603 int res2 = 0 ;
37604 bool val3 ;
37605 int ecode3 = 0 ;
37606 PyObject * obj0 = 0 ;
37607 PyObject * obj1 = 0 ;
37608 PyObject * obj2 = 0 ;
37609 char * kwnames[] = {
37610 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37611 };
37612
37613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37615 if (!SWIG_IsOK(res1)) {
37616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37617 }
37618 arg1 = reinterpret_cast< wxWindow * >(argp1);
37619 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37620 if (!SWIG_IsOK(res2)) {
37621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37622 }
37623 if (obj2) {
37624 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37625 if (!SWIG_IsOK(ecode3)) {
37626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37627 }
37628 arg3 = static_cast< bool >(val3);
37629 }
37630 {
37631 PyThreadState* __tstate = wxPyBeginAllowThreads();
37632 (arg1)->SetSizer(arg2,arg3);
37633 wxPyEndAllowThreads(__tstate);
37634 if (PyErr_Occurred()) SWIG_fail;
37635 }
37636 resultobj = SWIG_Py_Void();
37637 return resultobj;
37638 fail:
37639 return NULL;
37640 }
37641
37642
37643 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37644 PyObject *resultobj = 0;
37645 wxWindow *arg1 = (wxWindow *) 0 ;
37646 wxSizer *arg2 = (wxSizer *) 0 ;
37647 bool arg3 = (bool) true ;
37648 void *argp1 = 0 ;
37649 int res1 = 0 ;
37650 int res2 = 0 ;
37651 bool val3 ;
37652 int ecode3 = 0 ;
37653 PyObject * obj0 = 0 ;
37654 PyObject * obj1 = 0 ;
37655 PyObject * obj2 = 0 ;
37656 char * kwnames[] = {
37657 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37658 };
37659
37660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37662 if (!SWIG_IsOK(res1)) {
37663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37664 }
37665 arg1 = reinterpret_cast< wxWindow * >(argp1);
37666 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37667 if (!SWIG_IsOK(res2)) {
37668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37669 }
37670 if (obj2) {
37671 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37672 if (!SWIG_IsOK(ecode3)) {
37673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37674 }
37675 arg3 = static_cast< bool >(val3);
37676 }
37677 {
37678 PyThreadState* __tstate = wxPyBeginAllowThreads();
37679 (arg1)->SetSizerAndFit(arg2,arg3);
37680 wxPyEndAllowThreads(__tstate);
37681 if (PyErr_Occurred()) SWIG_fail;
37682 }
37683 resultobj = SWIG_Py_Void();
37684 return resultobj;
37685 fail:
37686 return NULL;
37687 }
37688
37689
37690 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37691 PyObject *resultobj = 0;
37692 wxWindow *arg1 = (wxWindow *) 0 ;
37693 wxSizer *result = 0 ;
37694 void *argp1 = 0 ;
37695 int res1 = 0 ;
37696 PyObject *swig_obj[1] ;
37697
37698 if (!args) SWIG_fail;
37699 swig_obj[0] = args;
37700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37701 if (!SWIG_IsOK(res1)) {
37702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37703 }
37704 arg1 = reinterpret_cast< wxWindow * >(argp1);
37705 {
37706 PyThreadState* __tstate = wxPyBeginAllowThreads();
37707 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37708 wxPyEndAllowThreads(__tstate);
37709 if (PyErr_Occurred()) SWIG_fail;
37710 }
37711 {
37712 resultobj = wxPyMake_wxObject(result, (bool)0);
37713 }
37714 return resultobj;
37715 fail:
37716 return NULL;
37717 }
37718
37719
37720 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37721 PyObject *resultobj = 0;
37722 wxWindow *arg1 = (wxWindow *) 0 ;
37723 wxSizer *arg2 = (wxSizer *) 0 ;
37724 void *argp1 = 0 ;
37725 int res1 = 0 ;
37726 void *argp2 = 0 ;
37727 int res2 = 0 ;
37728 PyObject * obj0 = 0 ;
37729 PyObject * obj1 = 0 ;
37730 char * kwnames[] = {
37731 (char *) "self",(char *) "sizer", NULL
37732 };
37733
37734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37736 if (!SWIG_IsOK(res1)) {
37737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37738 }
37739 arg1 = reinterpret_cast< wxWindow * >(argp1);
37740 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37741 if (!SWIG_IsOK(res2)) {
37742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37743 }
37744 arg2 = reinterpret_cast< wxSizer * >(argp2);
37745 {
37746 PyThreadState* __tstate = wxPyBeginAllowThreads();
37747 (arg1)->SetContainingSizer(arg2);
37748 wxPyEndAllowThreads(__tstate);
37749 if (PyErr_Occurred()) SWIG_fail;
37750 }
37751 resultobj = SWIG_Py_Void();
37752 return resultobj;
37753 fail:
37754 return NULL;
37755 }
37756
37757
37758 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37759 PyObject *resultobj = 0;
37760 wxWindow *arg1 = (wxWindow *) 0 ;
37761 wxSizer *result = 0 ;
37762 void *argp1 = 0 ;
37763 int res1 = 0 ;
37764 PyObject *swig_obj[1] ;
37765
37766 if (!args) SWIG_fail;
37767 swig_obj[0] = args;
37768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37769 if (!SWIG_IsOK(res1)) {
37770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37771 }
37772 arg1 = reinterpret_cast< wxWindow * >(argp1);
37773 {
37774 PyThreadState* __tstate = wxPyBeginAllowThreads();
37775 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37776 wxPyEndAllowThreads(__tstate);
37777 if (PyErr_Occurred()) SWIG_fail;
37778 }
37779 {
37780 resultobj = wxPyMake_wxObject(result, (bool)0);
37781 }
37782 return resultobj;
37783 fail:
37784 return NULL;
37785 }
37786
37787
37788 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37789 PyObject *resultobj = 0;
37790 wxWindow *arg1 = (wxWindow *) 0 ;
37791 void *argp1 = 0 ;
37792 int res1 = 0 ;
37793 PyObject *swig_obj[1] ;
37794
37795 if (!args) SWIG_fail;
37796 swig_obj[0] = args;
37797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37798 if (!SWIG_IsOK(res1)) {
37799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37800 }
37801 arg1 = reinterpret_cast< wxWindow * >(argp1);
37802 {
37803 PyThreadState* __tstate = wxPyBeginAllowThreads();
37804 (arg1)->InheritAttributes();
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 resultobj = SWIG_Py_Void();
37809 return resultobj;
37810 fail:
37811 return NULL;
37812 }
37813
37814
37815 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37816 PyObject *resultobj = 0;
37817 wxWindow *arg1 = (wxWindow *) 0 ;
37818 bool result;
37819 void *argp1 = 0 ;
37820 int res1 = 0 ;
37821 PyObject *swig_obj[1] ;
37822
37823 if (!args) SWIG_fail;
37824 swig_obj[0] = args;
37825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37826 if (!SWIG_IsOK(res1)) {
37827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37828 }
37829 arg1 = reinterpret_cast< wxWindow * >(argp1);
37830 {
37831 PyThreadState* __tstate = wxPyBeginAllowThreads();
37832 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37833 wxPyEndAllowThreads(__tstate);
37834 if (PyErr_Occurred()) SWIG_fail;
37835 }
37836 {
37837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37838 }
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37846 PyObject *resultobj = 0;
37847 wxWindow *arg1 = (wxWindow *) 0 ;
37848 bool result;
37849 void *argp1 = 0 ;
37850 int res1 = 0 ;
37851 PyObject *swig_obj[1] ;
37852
37853 if (!args) SWIG_fail;
37854 swig_obj[0] = args;
37855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37856 if (!SWIG_IsOK(res1)) {
37857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37858 }
37859 arg1 = reinterpret_cast< wxWindow * >(argp1);
37860 {
37861 PyThreadState* __tstate = wxPyBeginAllowThreads();
37862 result = (bool)(arg1)->CanSetTransparent();
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 {
37867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37868 }
37869 return resultobj;
37870 fail:
37871 return NULL;
37872 }
37873
37874
37875 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37876 PyObject *resultobj = 0;
37877 wxWindow *arg1 = (wxWindow *) 0 ;
37878 byte arg2 ;
37879 bool result;
37880 void *argp1 = 0 ;
37881 int res1 = 0 ;
37882 unsigned char val2 ;
37883 int ecode2 = 0 ;
37884 PyObject * obj0 = 0 ;
37885 PyObject * obj1 = 0 ;
37886 char * kwnames[] = {
37887 (char *) "self",(char *) "alpha", NULL
37888 };
37889
37890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37892 if (!SWIG_IsOK(res1)) {
37893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37894 }
37895 arg1 = reinterpret_cast< wxWindow * >(argp1);
37896 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37897 if (!SWIG_IsOK(ecode2)) {
37898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37899 }
37900 arg2 = static_cast< byte >(val2);
37901 {
37902 PyThreadState* __tstate = wxPyBeginAllowThreads();
37903 result = (bool)(arg1)->SetTransparent(arg2);
37904 wxPyEndAllowThreads(__tstate);
37905 if (PyErr_Occurred()) SWIG_fail;
37906 }
37907 {
37908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37909 }
37910 return resultobj;
37911 fail:
37912 return NULL;
37913 }
37914
37915
37916 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37917 PyObject *obj;
37918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37919 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37920 return SWIG_Py_Void();
37921 }
37922
37923 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37924 return SWIG_Python_InitShadowInstance(args);
37925 }
37926
37927 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37928 PyObject *resultobj = 0;
37929 long arg1 ;
37930 wxWindow *arg2 = (wxWindow *) NULL ;
37931 wxWindow *result = 0 ;
37932 long val1 ;
37933 int ecode1 = 0 ;
37934 void *argp2 = 0 ;
37935 int res2 = 0 ;
37936 PyObject * obj0 = 0 ;
37937 PyObject * obj1 = 0 ;
37938 char * kwnames[] = {
37939 (char *) "id",(char *) "parent", NULL
37940 };
37941
37942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37943 ecode1 = SWIG_AsVal_long(obj0, &val1);
37944 if (!SWIG_IsOK(ecode1)) {
37945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37946 }
37947 arg1 = static_cast< long >(val1);
37948 if (obj1) {
37949 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37950 if (!SWIG_IsOK(res2)) {
37951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37952 }
37953 arg2 = reinterpret_cast< wxWindow * >(argp2);
37954 }
37955 {
37956 if (!wxPyCheckForApp()) SWIG_fail;
37957 PyThreadState* __tstate = wxPyBeginAllowThreads();
37958 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37959 wxPyEndAllowThreads(__tstate);
37960 if (PyErr_Occurred()) SWIG_fail;
37961 }
37962 {
37963 resultobj = wxPyMake_wxObject(result, 0);
37964 }
37965 return resultobj;
37966 fail:
37967 return NULL;
37968 }
37969
37970
37971 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37972 PyObject *resultobj = 0;
37973 wxString *arg1 = 0 ;
37974 wxWindow *arg2 = (wxWindow *) NULL ;
37975 wxWindow *result = 0 ;
37976 bool temp1 = false ;
37977 void *argp2 = 0 ;
37978 int res2 = 0 ;
37979 PyObject * obj0 = 0 ;
37980 PyObject * obj1 = 0 ;
37981 char * kwnames[] = {
37982 (char *) "name",(char *) "parent", NULL
37983 };
37984
37985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37986 {
37987 arg1 = wxString_in_helper(obj0);
37988 if (arg1 == NULL) SWIG_fail;
37989 temp1 = true;
37990 }
37991 if (obj1) {
37992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37993 if (!SWIG_IsOK(res2)) {
37994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37995 }
37996 arg2 = reinterpret_cast< wxWindow * >(argp2);
37997 }
37998 {
37999 if (!wxPyCheckForApp()) SWIG_fail;
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 {
38006 resultobj = wxPyMake_wxObject(result, 0);
38007 }
38008 {
38009 if (temp1)
38010 delete arg1;
38011 }
38012 return resultobj;
38013 fail:
38014 {
38015 if (temp1)
38016 delete arg1;
38017 }
38018 return NULL;
38019 }
38020
38021
38022 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38023 PyObject *resultobj = 0;
38024 wxString *arg1 = 0 ;
38025 wxWindow *arg2 = (wxWindow *) NULL ;
38026 wxWindow *result = 0 ;
38027 bool temp1 = false ;
38028 void *argp2 = 0 ;
38029 int res2 = 0 ;
38030 PyObject * obj0 = 0 ;
38031 PyObject * obj1 = 0 ;
38032 char * kwnames[] = {
38033 (char *) "label",(char *) "parent", NULL
38034 };
38035
38036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38037 {
38038 arg1 = wxString_in_helper(obj0);
38039 if (arg1 == NULL) SWIG_fail;
38040 temp1 = true;
38041 }
38042 if (obj1) {
38043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38044 if (!SWIG_IsOK(res2)) {
38045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38046 }
38047 arg2 = reinterpret_cast< wxWindow * >(argp2);
38048 }
38049 {
38050 if (!wxPyCheckForApp()) SWIG_fail;
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38053 wxPyEndAllowThreads(__tstate);
38054 if (PyErr_Occurred()) SWIG_fail;
38055 }
38056 {
38057 resultobj = wxPyMake_wxObject(result, 0);
38058 }
38059 {
38060 if (temp1)
38061 delete arg1;
38062 }
38063 return resultobj;
38064 fail:
38065 {
38066 if (temp1)
38067 delete arg1;
38068 }
38069 return NULL;
38070 }
38071
38072
38073 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38074 PyObject *resultobj = 0;
38075 wxWindow *arg1 = (wxWindow *) 0 ;
38076 unsigned long arg2 ;
38077 wxWindow *result = 0 ;
38078 void *argp1 = 0 ;
38079 int res1 = 0 ;
38080 unsigned long val2 ;
38081 int ecode2 = 0 ;
38082 PyObject * obj0 = 0 ;
38083 PyObject * obj1 = 0 ;
38084 char * kwnames[] = {
38085 (char *) "parent",(char *) "_hWnd", NULL
38086 };
38087
38088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38090 if (!SWIG_IsOK(res1)) {
38091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38092 }
38093 arg1 = reinterpret_cast< wxWindow * >(argp1);
38094 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38095 if (!SWIG_IsOK(ecode2)) {
38096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38097 }
38098 arg2 = static_cast< unsigned long >(val2);
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 {
38106 resultobj = wxPyMake_wxObject(result, 0);
38107 }
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38115 PyObject *resultobj = 0;
38116 PyObject *result = 0 ;
38117
38118 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38119 {
38120 PyThreadState* __tstate = wxPyBeginAllowThreads();
38121 result = (PyObject *)GetTopLevelWindows();
38122 wxPyEndAllowThreads(__tstate);
38123 if (PyErr_Occurred()) SWIG_fail;
38124 }
38125 resultobj = result;
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38133 PyObject *resultobj = 0;
38134 wxValidator *result = 0 ;
38135
38136 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38137 {
38138 PyThreadState* __tstate = wxPyBeginAllowThreads();
38139 result = (wxValidator *)new wxValidator();
38140 wxPyEndAllowThreads(__tstate);
38141 if (PyErr_Occurred()) SWIG_fail;
38142 }
38143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38144 return resultobj;
38145 fail:
38146 return NULL;
38147 }
38148
38149
38150 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38151 PyObject *resultobj = 0;
38152 wxValidator *arg1 = (wxValidator *) 0 ;
38153 wxValidator *result = 0 ;
38154 void *argp1 = 0 ;
38155 int res1 = 0 ;
38156 PyObject *swig_obj[1] ;
38157
38158 if (!args) SWIG_fail;
38159 swig_obj[0] = args;
38160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38163 }
38164 arg1 = reinterpret_cast< wxValidator * >(argp1);
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 result = (wxValidator *)(arg1)->Clone();
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 {
38172 resultobj = wxPyMake_wxObject(result, 0);
38173 }
38174 return resultobj;
38175 fail:
38176 return NULL;
38177 }
38178
38179
38180 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38181 PyObject *resultobj = 0;
38182 wxValidator *arg1 = (wxValidator *) 0 ;
38183 wxWindow *arg2 = (wxWindow *) 0 ;
38184 bool result;
38185 void *argp1 = 0 ;
38186 int res1 = 0 ;
38187 void *argp2 = 0 ;
38188 int res2 = 0 ;
38189 PyObject * obj0 = 0 ;
38190 PyObject * obj1 = 0 ;
38191 char * kwnames[] = {
38192 (char *) "self",(char *) "parent", NULL
38193 };
38194
38195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38197 if (!SWIG_IsOK(res1)) {
38198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38199 }
38200 arg1 = reinterpret_cast< wxValidator * >(argp1);
38201 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38202 if (!SWIG_IsOK(res2)) {
38203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38204 }
38205 arg2 = reinterpret_cast< wxWindow * >(argp2);
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 result = (bool)(arg1)->Validate(arg2);
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 {
38213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38214 }
38215 return resultobj;
38216 fail:
38217 return NULL;
38218 }
38219
38220
38221 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38222 PyObject *resultobj = 0;
38223 wxValidator *arg1 = (wxValidator *) 0 ;
38224 bool result;
38225 void *argp1 = 0 ;
38226 int res1 = 0 ;
38227 PyObject *swig_obj[1] ;
38228
38229 if (!args) SWIG_fail;
38230 swig_obj[0] = args;
38231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38232 if (!SWIG_IsOK(res1)) {
38233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38234 }
38235 arg1 = reinterpret_cast< wxValidator * >(argp1);
38236 {
38237 PyThreadState* __tstate = wxPyBeginAllowThreads();
38238 result = (bool)(arg1)->TransferToWindow();
38239 wxPyEndAllowThreads(__tstate);
38240 if (PyErr_Occurred()) SWIG_fail;
38241 }
38242 {
38243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38244 }
38245 return resultobj;
38246 fail:
38247 return NULL;
38248 }
38249
38250
38251 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38252 PyObject *resultobj = 0;
38253 wxValidator *arg1 = (wxValidator *) 0 ;
38254 bool result;
38255 void *argp1 = 0 ;
38256 int res1 = 0 ;
38257 PyObject *swig_obj[1] ;
38258
38259 if (!args) SWIG_fail;
38260 swig_obj[0] = args;
38261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38262 if (!SWIG_IsOK(res1)) {
38263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38264 }
38265 arg1 = reinterpret_cast< wxValidator * >(argp1);
38266 {
38267 PyThreadState* __tstate = wxPyBeginAllowThreads();
38268 result = (bool)(arg1)->TransferFromWindow();
38269 wxPyEndAllowThreads(__tstate);
38270 if (PyErr_Occurred()) SWIG_fail;
38271 }
38272 {
38273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38274 }
38275 return resultobj;
38276 fail:
38277 return NULL;
38278 }
38279
38280
38281 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38282 PyObject *resultobj = 0;
38283 wxValidator *arg1 = (wxValidator *) 0 ;
38284 wxWindow *result = 0 ;
38285 void *argp1 = 0 ;
38286 int res1 = 0 ;
38287 PyObject *swig_obj[1] ;
38288
38289 if (!args) SWIG_fail;
38290 swig_obj[0] = args;
38291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38292 if (!SWIG_IsOK(res1)) {
38293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38294 }
38295 arg1 = reinterpret_cast< wxValidator * >(argp1);
38296 {
38297 PyThreadState* __tstate = wxPyBeginAllowThreads();
38298 result = (wxWindow *)(arg1)->GetWindow();
38299 wxPyEndAllowThreads(__tstate);
38300 if (PyErr_Occurred()) SWIG_fail;
38301 }
38302 {
38303 resultobj = wxPyMake_wxObject(result, 0);
38304 }
38305 return resultobj;
38306 fail:
38307 return NULL;
38308 }
38309
38310
38311 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38312 PyObject *resultobj = 0;
38313 wxValidator *arg1 = (wxValidator *) 0 ;
38314 wxWindow *arg2 = (wxWindow *) 0 ;
38315 void *argp1 = 0 ;
38316 int res1 = 0 ;
38317 void *argp2 = 0 ;
38318 int res2 = 0 ;
38319 PyObject * obj0 = 0 ;
38320 PyObject * obj1 = 0 ;
38321 char * kwnames[] = {
38322 (char *) "self",(char *) "window", NULL
38323 };
38324
38325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38327 if (!SWIG_IsOK(res1)) {
38328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38329 }
38330 arg1 = reinterpret_cast< wxValidator * >(argp1);
38331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38332 if (!SWIG_IsOK(res2)) {
38333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38334 }
38335 arg2 = reinterpret_cast< wxWindow * >(argp2);
38336 {
38337 PyThreadState* __tstate = wxPyBeginAllowThreads();
38338 (arg1)->SetWindow(arg2);
38339 wxPyEndAllowThreads(__tstate);
38340 if (PyErr_Occurred()) SWIG_fail;
38341 }
38342 resultobj = SWIG_Py_Void();
38343 return resultobj;
38344 fail:
38345 return NULL;
38346 }
38347
38348
38349 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38350 PyObject *resultobj = 0;
38351 bool result;
38352
38353 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 result = (bool)wxValidator::IsSilent();
38357 wxPyEndAllowThreads(__tstate);
38358 if (PyErr_Occurred()) SWIG_fail;
38359 }
38360 {
38361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38362 }
38363 return resultobj;
38364 fail:
38365 return NULL;
38366 }
38367
38368
38369 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38370 PyObject *resultobj = 0;
38371 int arg1 = (int) true ;
38372 int val1 ;
38373 int ecode1 = 0 ;
38374 PyObject * obj0 = 0 ;
38375 char * kwnames[] = {
38376 (char *) "doIt", NULL
38377 };
38378
38379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38380 if (obj0) {
38381 ecode1 = SWIG_AsVal_int(obj0, &val1);
38382 if (!SWIG_IsOK(ecode1)) {
38383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38384 }
38385 arg1 = static_cast< int >(val1);
38386 }
38387 {
38388 PyThreadState* __tstate = wxPyBeginAllowThreads();
38389 wxValidator::SetBellOnError(arg1);
38390 wxPyEndAllowThreads(__tstate);
38391 if (PyErr_Occurred()) SWIG_fail;
38392 }
38393 resultobj = SWIG_Py_Void();
38394 return resultobj;
38395 fail:
38396 return NULL;
38397 }
38398
38399
38400 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38401 PyObject *obj;
38402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38403 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38404 return SWIG_Py_Void();
38405 }
38406
38407 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38408 return SWIG_Python_InitShadowInstance(args);
38409 }
38410
38411 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38412 PyObject *resultobj = 0;
38413 wxPyValidator *result = 0 ;
38414
38415 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38416 {
38417 PyThreadState* __tstate = wxPyBeginAllowThreads();
38418 result = (wxPyValidator *)new wxPyValidator();
38419 wxPyEndAllowThreads(__tstate);
38420 if (PyErr_Occurred()) SWIG_fail;
38421 }
38422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38423 return resultobj;
38424 fail:
38425 return NULL;
38426 }
38427
38428
38429 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38430 PyObject *resultobj = 0;
38431 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38432 PyObject *arg2 = (PyObject *) 0 ;
38433 PyObject *arg3 = (PyObject *) 0 ;
38434 int arg4 = (int) true ;
38435 void *argp1 = 0 ;
38436 int res1 = 0 ;
38437 int val4 ;
38438 int ecode4 = 0 ;
38439 PyObject * obj0 = 0 ;
38440 PyObject * obj1 = 0 ;
38441 PyObject * obj2 = 0 ;
38442 PyObject * obj3 = 0 ;
38443 char * kwnames[] = {
38444 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38445 };
38446
38447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38449 if (!SWIG_IsOK(res1)) {
38450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38451 }
38452 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38453 arg2 = obj1;
38454 arg3 = obj2;
38455 if (obj3) {
38456 ecode4 = SWIG_AsVal_int(obj3, &val4);
38457 if (!SWIG_IsOK(ecode4)) {
38458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38459 }
38460 arg4 = static_cast< int >(val4);
38461 }
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 resultobj = SWIG_Py_Void();
38469 return resultobj;
38470 fail:
38471 return NULL;
38472 }
38473
38474
38475 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38476 PyObject *obj;
38477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38478 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38479 return SWIG_Py_Void();
38480 }
38481
38482 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38483 return SWIG_Python_InitShadowInstance(args);
38484 }
38485
38486 SWIGINTERN int DefaultValidator_set(PyObject *) {
38487 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38488 return 1;
38489 }
38490
38491
38492 SWIGINTERN PyObject *DefaultValidator_get(void) {
38493 PyObject *pyobj = 0;
38494
38495 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38496 return pyobj;
38497 }
38498
38499
38500 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38501 PyObject *resultobj = 0;
38502 wxString const &arg1_defvalue = wxPyEmptyString ;
38503 wxString *arg1 = (wxString *) &arg1_defvalue ;
38504 long arg2 = (long) 0 ;
38505 wxMenu *result = 0 ;
38506 bool temp1 = false ;
38507 long val2 ;
38508 int ecode2 = 0 ;
38509 PyObject * obj0 = 0 ;
38510 PyObject * obj1 = 0 ;
38511 char * kwnames[] = {
38512 (char *) "title",(char *) "style", NULL
38513 };
38514
38515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38516 if (obj0) {
38517 {
38518 arg1 = wxString_in_helper(obj0);
38519 if (arg1 == NULL) SWIG_fail;
38520 temp1 = true;
38521 }
38522 }
38523 if (obj1) {
38524 ecode2 = SWIG_AsVal_long(obj1, &val2);
38525 if (!SWIG_IsOK(ecode2)) {
38526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38527 }
38528 arg2 = static_cast< long >(val2);
38529 }
38530 {
38531 if (!wxPyCheckForApp()) SWIG_fail;
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38534 wxPyEndAllowThreads(__tstate);
38535 if (PyErr_Occurred()) SWIG_fail;
38536 }
38537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38538 {
38539 if (temp1)
38540 delete arg1;
38541 }
38542 return resultobj;
38543 fail:
38544 {
38545 if (temp1)
38546 delete arg1;
38547 }
38548 return NULL;
38549 }
38550
38551
38552 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38553 PyObject *resultobj = 0;
38554 wxMenu *arg1 = (wxMenu *) 0 ;
38555 int arg2 ;
38556 wxString *arg3 = 0 ;
38557 wxString const &arg4_defvalue = wxPyEmptyString ;
38558 wxString *arg4 = (wxString *) &arg4_defvalue ;
38559 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38560 wxMenuItem *result = 0 ;
38561 void *argp1 = 0 ;
38562 int res1 = 0 ;
38563 int val2 ;
38564 int ecode2 = 0 ;
38565 bool temp3 = false ;
38566 bool temp4 = false ;
38567 int val5 ;
38568 int ecode5 = 0 ;
38569 PyObject * obj0 = 0 ;
38570 PyObject * obj1 = 0 ;
38571 PyObject * obj2 = 0 ;
38572 PyObject * obj3 = 0 ;
38573 PyObject * obj4 = 0 ;
38574 char * kwnames[] = {
38575 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38576 };
38577
38578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38580 if (!SWIG_IsOK(res1)) {
38581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38582 }
38583 arg1 = reinterpret_cast< wxMenu * >(argp1);
38584 ecode2 = SWIG_AsVal_int(obj1, &val2);
38585 if (!SWIG_IsOK(ecode2)) {
38586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38587 }
38588 arg2 = static_cast< int >(val2);
38589 {
38590 arg3 = wxString_in_helper(obj2);
38591 if (arg3 == NULL) SWIG_fail;
38592 temp3 = true;
38593 }
38594 if (obj3) {
38595 {
38596 arg4 = wxString_in_helper(obj3);
38597 if (arg4 == NULL) SWIG_fail;
38598 temp4 = true;
38599 }
38600 }
38601 if (obj4) {
38602 ecode5 = SWIG_AsVal_int(obj4, &val5);
38603 if (!SWIG_IsOK(ecode5)) {
38604 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38605 }
38606 arg5 = static_cast< wxItemKind >(val5);
38607 }
38608 {
38609 PyThreadState* __tstate = wxPyBeginAllowThreads();
38610 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38611 wxPyEndAllowThreads(__tstate);
38612 if (PyErr_Occurred()) SWIG_fail;
38613 }
38614 {
38615 resultobj = wxPyMake_wxObject(result, (bool)0);
38616 }
38617 {
38618 if (temp3)
38619 delete arg3;
38620 }
38621 {
38622 if (temp4)
38623 delete arg4;
38624 }
38625 return resultobj;
38626 fail:
38627 {
38628 if (temp3)
38629 delete arg3;
38630 }
38631 {
38632 if (temp4)
38633 delete arg4;
38634 }
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38640 PyObject *resultobj = 0;
38641 wxMenu *arg1 = (wxMenu *) 0 ;
38642 wxMenuItem *result = 0 ;
38643 void *argp1 = 0 ;
38644 int res1 = 0 ;
38645 PyObject *swig_obj[1] ;
38646
38647 if (!args) SWIG_fail;
38648 swig_obj[0] = args;
38649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38650 if (!SWIG_IsOK(res1)) {
38651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38652 }
38653 arg1 = reinterpret_cast< wxMenu * >(argp1);
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 result = (wxMenuItem *)(arg1)->AppendSeparator();
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 {
38661 resultobj = wxPyMake_wxObject(result, (bool)0);
38662 }
38663 return resultobj;
38664 fail:
38665 return NULL;
38666 }
38667
38668
38669 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38670 PyObject *resultobj = 0;
38671 wxMenu *arg1 = (wxMenu *) 0 ;
38672 int arg2 ;
38673 wxString *arg3 = 0 ;
38674 wxString const &arg4_defvalue = wxPyEmptyString ;
38675 wxString *arg4 = (wxString *) &arg4_defvalue ;
38676 wxMenuItem *result = 0 ;
38677 void *argp1 = 0 ;
38678 int res1 = 0 ;
38679 int val2 ;
38680 int ecode2 = 0 ;
38681 bool temp3 = false ;
38682 bool temp4 = false ;
38683 PyObject * obj0 = 0 ;
38684 PyObject * obj1 = 0 ;
38685 PyObject * obj2 = 0 ;
38686 PyObject * obj3 = 0 ;
38687 char * kwnames[] = {
38688 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38689 };
38690
38691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38693 if (!SWIG_IsOK(res1)) {
38694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38695 }
38696 arg1 = reinterpret_cast< wxMenu * >(argp1);
38697 ecode2 = SWIG_AsVal_int(obj1, &val2);
38698 if (!SWIG_IsOK(ecode2)) {
38699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38700 }
38701 arg2 = static_cast< int >(val2);
38702 {
38703 arg3 = wxString_in_helper(obj2);
38704 if (arg3 == NULL) SWIG_fail;
38705 temp3 = true;
38706 }
38707 if (obj3) {
38708 {
38709 arg4 = wxString_in_helper(obj3);
38710 if (arg4 == NULL) SWIG_fail;
38711 temp4 = true;
38712 }
38713 }
38714 {
38715 PyThreadState* __tstate = wxPyBeginAllowThreads();
38716 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38717 wxPyEndAllowThreads(__tstate);
38718 if (PyErr_Occurred()) SWIG_fail;
38719 }
38720 {
38721 resultobj = wxPyMake_wxObject(result, (bool)0);
38722 }
38723 {
38724 if (temp3)
38725 delete arg3;
38726 }
38727 {
38728 if (temp4)
38729 delete arg4;
38730 }
38731 return resultobj;
38732 fail:
38733 {
38734 if (temp3)
38735 delete arg3;
38736 }
38737 {
38738 if (temp4)
38739 delete arg4;
38740 }
38741 return NULL;
38742 }
38743
38744
38745 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38746 PyObject *resultobj = 0;
38747 wxMenu *arg1 = (wxMenu *) 0 ;
38748 int arg2 ;
38749 wxString *arg3 = 0 ;
38750 wxString const &arg4_defvalue = wxPyEmptyString ;
38751 wxString *arg4 = (wxString *) &arg4_defvalue ;
38752 wxMenuItem *result = 0 ;
38753 void *argp1 = 0 ;
38754 int res1 = 0 ;
38755 int val2 ;
38756 int ecode2 = 0 ;
38757 bool temp3 = false ;
38758 bool temp4 = false ;
38759 PyObject * obj0 = 0 ;
38760 PyObject * obj1 = 0 ;
38761 PyObject * obj2 = 0 ;
38762 PyObject * obj3 = 0 ;
38763 char * kwnames[] = {
38764 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38765 };
38766
38767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38769 if (!SWIG_IsOK(res1)) {
38770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38771 }
38772 arg1 = reinterpret_cast< wxMenu * >(argp1);
38773 ecode2 = SWIG_AsVal_int(obj1, &val2);
38774 if (!SWIG_IsOK(ecode2)) {
38775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38776 }
38777 arg2 = static_cast< int >(val2);
38778 {
38779 arg3 = wxString_in_helper(obj2);
38780 if (arg3 == NULL) SWIG_fail;
38781 temp3 = true;
38782 }
38783 if (obj3) {
38784 {
38785 arg4 = wxString_in_helper(obj3);
38786 if (arg4 == NULL) SWIG_fail;
38787 temp4 = true;
38788 }
38789 }
38790 {
38791 PyThreadState* __tstate = wxPyBeginAllowThreads();
38792 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38793 wxPyEndAllowThreads(__tstate);
38794 if (PyErr_Occurred()) SWIG_fail;
38795 }
38796 {
38797 resultobj = wxPyMake_wxObject(result, (bool)0);
38798 }
38799 {
38800 if (temp3)
38801 delete arg3;
38802 }
38803 {
38804 if (temp4)
38805 delete arg4;
38806 }
38807 return resultobj;
38808 fail:
38809 {
38810 if (temp3)
38811 delete arg3;
38812 }
38813 {
38814 if (temp4)
38815 delete arg4;
38816 }
38817 return NULL;
38818 }
38819
38820
38821 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38822 PyObject *resultobj = 0;
38823 wxMenu *arg1 = (wxMenu *) 0 ;
38824 int arg2 ;
38825 wxString *arg3 = 0 ;
38826 wxMenu *arg4 = (wxMenu *) 0 ;
38827 wxString const &arg5_defvalue = wxPyEmptyString ;
38828 wxString *arg5 = (wxString *) &arg5_defvalue ;
38829 wxMenuItem *result = 0 ;
38830 void *argp1 = 0 ;
38831 int res1 = 0 ;
38832 int val2 ;
38833 int ecode2 = 0 ;
38834 bool temp3 = false ;
38835 void *argp4 = 0 ;
38836 int res4 = 0 ;
38837 bool temp5 = false ;
38838 PyObject * obj0 = 0 ;
38839 PyObject * obj1 = 0 ;
38840 PyObject * obj2 = 0 ;
38841 PyObject * obj3 = 0 ;
38842 PyObject * obj4 = 0 ;
38843 char * kwnames[] = {
38844 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38845 };
38846
38847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38849 if (!SWIG_IsOK(res1)) {
38850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38851 }
38852 arg1 = reinterpret_cast< wxMenu * >(argp1);
38853 ecode2 = SWIG_AsVal_int(obj1, &val2);
38854 if (!SWIG_IsOK(ecode2)) {
38855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38856 }
38857 arg2 = static_cast< int >(val2);
38858 {
38859 arg3 = wxString_in_helper(obj2);
38860 if (arg3 == NULL) SWIG_fail;
38861 temp3 = true;
38862 }
38863 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38864 if (!SWIG_IsOK(res4)) {
38865 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38866 }
38867 arg4 = reinterpret_cast< wxMenu * >(argp4);
38868 if (obj4) {
38869 {
38870 arg5 = wxString_in_helper(obj4);
38871 if (arg5 == NULL) SWIG_fail;
38872 temp5 = true;
38873 }
38874 }
38875 {
38876 PyThreadState* __tstate = wxPyBeginAllowThreads();
38877 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38878 wxPyEndAllowThreads(__tstate);
38879 if (PyErr_Occurred()) SWIG_fail;
38880 }
38881 {
38882 resultobj = wxPyMake_wxObject(result, (bool)0);
38883 }
38884 {
38885 if (temp3)
38886 delete arg3;
38887 }
38888 {
38889 if (temp5)
38890 delete arg5;
38891 }
38892 return resultobj;
38893 fail:
38894 {
38895 if (temp3)
38896 delete arg3;
38897 }
38898 {
38899 if (temp5)
38900 delete arg5;
38901 }
38902 return NULL;
38903 }
38904
38905
38906 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38907 PyObject *resultobj = 0;
38908 wxMenu *arg1 = (wxMenu *) 0 ;
38909 wxMenu *arg2 = (wxMenu *) 0 ;
38910 wxString *arg3 = 0 ;
38911 wxString const &arg4_defvalue = wxPyEmptyString ;
38912 wxString *arg4 = (wxString *) &arg4_defvalue ;
38913 wxMenuItem *result = 0 ;
38914 void *argp1 = 0 ;
38915 int res1 = 0 ;
38916 void *argp2 = 0 ;
38917 int res2 = 0 ;
38918 bool temp3 = false ;
38919 bool temp4 = false ;
38920 PyObject * obj0 = 0 ;
38921 PyObject * obj1 = 0 ;
38922 PyObject * obj2 = 0 ;
38923 PyObject * obj3 = 0 ;
38924 char * kwnames[] = {
38925 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38926 };
38927
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38932 }
38933 arg1 = reinterpret_cast< wxMenu * >(argp1);
38934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38935 if (!SWIG_IsOK(res2)) {
38936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38937 }
38938 arg2 = reinterpret_cast< wxMenu * >(argp2);
38939 {
38940 arg3 = wxString_in_helper(obj2);
38941 if (arg3 == NULL) SWIG_fail;
38942 temp3 = true;
38943 }
38944 if (obj3) {
38945 {
38946 arg4 = wxString_in_helper(obj3);
38947 if (arg4 == NULL) SWIG_fail;
38948 temp4 = true;
38949 }
38950 }
38951 {
38952 PyThreadState* __tstate = wxPyBeginAllowThreads();
38953 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38954 wxPyEndAllowThreads(__tstate);
38955 if (PyErr_Occurred()) SWIG_fail;
38956 }
38957 {
38958 resultobj = wxPyMake_wxObject(result, (bool)0);
38959 }
38960 {
38961 if (temp3)
38962 delete arg3;
38963 }
38964 {
38965 if (temp4)
38966 delete arg4;
38967 }
38968 return resultobj;
38969 fail:
38970 {
38971 if (temp3)
38972 delete arg3;
38973 }
38974 {
38975 if (temp4)
38976 delete arg4;
38977 }
38978 return NULL;
38979 }
38980
38981
38982 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38983 PyObject *resultobj = 0;
38984 wxMenu *arg1 = (wxMenu *) 0 ;
38985 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38986 wxMenuItem *result = 0 ;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 int res2 = 0 ;
38990 PyObject * obj0 = 0 ;
38991 PyObject * obj1 = 0 ;
38992 char * kwnames[] = {
38993 (char *) "self",(char *) "item", NULL
38994 };
38995
38996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38998 if (!SWIG_IsOK(res1)) {
38999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39000 }
39001 arg1 = reinterpret_cast< wxMenu * >(argp1);
39002 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39003 if (!SWIG_IsOK(res2)) {
39004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39005 }
39006 {
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 result = (wxMenuItem *)(arg1)->Append(arg2);
39009 wxPyEndAllowThreads(__tstate);
39010 if (PyErr_Occurred()) SWIG_fail;
39011 }
39012 {
39013 resultobj = wxPyMake_wxObject(result, (bool)0);
39014 }
39015 return resultobj;
39016 fail:
39017 return NULL;
39018 }
39019
39020
39021 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39022 PyObject *resultobj = 0;
39023 wxMenu *arg1 = (wxMenu *) 0 ;
39024 size_t arg2 ;
39025 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39026 wxMenuItem *result = 0 ;
39027 void *argp1 = 0 ;
39028 int res1 = 0 ;
39029 size_t val2 ;
39030 int ecode2 = 0 ;
39031 int res3 = 0 ;
39032 PyObject * obj0 = 0 ;
39033 PyObject * obj1 = 0 ;
39034 PyObject * obj2 = 0 ;
39035 char * kwnames[] = {
39036 (char *) "self",(char *) "pos",(char *) "item", NULL
39037 };
39038
39039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39041 if (!SWIG_IsOK(res1)) {
39042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39043 }
39044 arg1 = reinterpret_cast< wxMenu * >(argp1);
39045 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39046 if (!SWIG_IsOK(ecode2)) {
39047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39048 }
39049 arg2 = static_cast< size_t >(val2);
39050 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39051 if (!SWIG_IsOK(res3)) {
39052 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39053 }
39054 {
39055 PyThreadState* __tstate = wxPyBeginAllowThreads();
39056 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39057 wxPyEndAllowThreads(__tstate);
39058 if (PyErr_Occurred()) SWIG_fail;
39059 }
39060 {
39061 resultobj = wxPyMake_wxObject(result, (bool)0);
39062 }
39063 return resultobj;
39064 fail:
39065 return NULL;
39066 }
39067
39068
39069 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39070 PyObject *resultobj = 0;
39071 wxMenu *arg1 = (wxMenu *) 0 ;
39072 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39073 wxMenuItem *result = 0 ;
39074 void *argp1 = 0 ;
39075 int res1 = 0 ;
39076 int res2 = 0 ;
39077 PyObject * obj0 = 0 ;
39078 PyObject * obj1 = 0 ;
39079 char * kwnames[] = {
39080 (char *) "self",(char *) "item", NULL
39081 };
39082
39083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39085 if (!SWIG_IsOK(res1)) {
39086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39087 }
39088 arg1 = reinterpret_cast< wxMenu * >(argp1);
39089 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39090 if (!SWIG_IsOK(res2)) {
39091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39092 }
39093 {
39094 PyThreadState* __tstate = wxPyBeginAllowThreads();
39095 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39096 wxPyEndAllowThreads(__tstate);
39097 if (PyErr_Occurred()) SWIG_fail;
39098 }
39099 {
39100 resultobj = wxPyMake_wxObject(result, (bool)0);
39101 }
39102 return resultobj;
39103 fail:
39104 return NULL;
39105 }
39106
39107
39108 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39109 PyObject *resultobj = 0;
39110 wxMenu *arg1 = (wxMenu *) 0 ;
39111 void *argp1 = 0 ;
39112 int res1 = 0 ;
39113 PyObject *swig_obj[1] ;
39114
39115 if (!args) SWIG_fail;
39116 swig_obj[0] = args;
39117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39118 if (!SWIG_IsOK(res1)) {
39119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39120 }
39121 arg1 = reinterpret_cast< wxMenu * >(argp1);
39122 {
39123 PyThreadState* __tstate = wxPyBeginAllowThreads();
39124 (arg1)->Break();
39125 wxPyEndAllowThreads(__tstate);
39126 if (PyErr_Occurred()) SWIG_fail;
39127 }
39128 resultobj = SWIG_Py_Void();
39129 return resultobj;
39130 fail:
39131 return NULL;
39132 }
39133
39134
39135 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj = 0;
39137 wxMenu *arg1 = (wxMenu *) 0 ;
39138 size_t arg2 ;
39139 int arg3 ;
39140 wxString *arg4 = 0 ;
39141 wxString const &arg5_defvalue = wxPyEmptyString ;
39142 wxString *arg5 = (wxString *) &arg5_defvalue ;
39143 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39144 wxMenuItem *result = 0 ;
39145 void *argp1 = 0 ;
39146 int res1 = 0 ;
39147 size_t val2 ;
39148 int ecode2 = 0 ;
39149 int val3 ;
39150 int ecode3 = 0 ;
39151 bool temp4 = false ;
39152 bool temp5 = false ;
39153 int val6 ;
39154 int ecode6 = 0 ;
39155 PyObject * obj0 = 0 ;
39156 PyObject * obj1 = 0 ;
39157 PyObject * obj2 = 0 ;
39158 PyObject * obj3 = 0 ;
39159 PyObject * obj4 = 0 ;
39160 PyObject * obj5 = 0 ;
39161 char * kwnames[] = {
39162 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39163 };
39164
39165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39167 if (!SWIG_IsOK(res1)) {
39168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39169 }
39170 arg1 = reinterpret_cast< wxMenu * >(argp1);
39171 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39172 if (!SWIG_IsOK(ecode2)) {
39173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39174 }
39175 arg2 = static_cast< size_t >(val2);
39176 ecode3 = SWIG_AsVal_int(obj2, &val3);
39177 if (!SWIG_IsOK(ecode3)) {
39178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39179 }
39180 arg3 = static_cast< int >(val3);
39181 {
39182 arg4 = wxString_in_helper(obj3);
39183 if (arg4 == NULL) SWIG_fail;
39184 temp4 = true;
39185 }
39186 if (obj4) {
39187 {
39188 arg5 = wxString_in_helper(obj4);
39189 if (arg5 == NULL) SWIG_fail;
39190 temp5 = true;
39191 }
39192 }
39193 if (obj5) {
39194 ecode6 = SWIG_AsVal_int(obj5, &val6);
39195 if (!SWIG_IsOK(ecode6)) {
39196 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39197 }
39198 arg6 = static_cast< wxItemKind >(val6);
39199 }
39200 {
39201 PyThreadState* __tstate = wxPyBeginAllowThreads();
39202 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39203 wxPyEndAllowThreads(__tstate);
39204 if (PyErr_Occurred()) SWIG_fail;
39205 }
39206 {
39207 resultobj = wxPyMake_wxObject(result, (bool)0);
39208 }
39209 {
39210 if (temp4)
39211 delete arg4;
39212 }
39213 {
39214 if (temp5)
39215 delete arg5;
39216 }
39217 return resultobj;
39218 fail:
39219 {
39220 if (temp4)
39221 delete arg4;
39222 }
39223 {
39224 if (temp5)
39225 delete arg5;
39226 }
39227 return NULL;
39228 }
39229
39230
39231 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39232 PyObject *resultobj = 0;
39233 wxMenu *arg1 = (wxMenu *) 0 ;
39234 size_t arg2 ;
39235 wxMenuItem *result = 0 ;
39236 void *argp1 = 0 ;
39237 int res1 = 0 ;
39238 size_t val2 ;
39239 int ecode2 = 0 ;
39240 PyObject * obj0 = 0 ;
39241 PyObject * obj1 = 0 ;
39242 char * kwnames[] = {
39243 (char *) "self",(char *) "pos", NULL
39244 };
39245
39246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39248 if (!SWIG_IsOK(res1)) {
39249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39250 }
39251 arg1 = reinterpret_cast< wxMenu * >(argp1);
39252 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39253 if (!SWIG_IsOK(ecode2)) {
39254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39255 }
39256 arg2 = static_cast< size_t >(val2);
39257 {
39258 PyThreadState* __tstate = wxPyBeginAllowThreads();
39259 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39260 wxPyEndAllowThreads(__tstate);
39261 if (PyErr_Occurred()) SWIG_fail;
39262 }
39263 {
39264 resultobj = wxPyMake_wxObject(result, (bool)0);
39265 }
39266 return resultobj;
39267 fail:
39268 return NULL;
39269 }
39270
39271
39272 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39273 PyObject *resultobj = 0;
39274 wxMenu *arg1 = (wxMenu *) 0 ;
39275 size_t arg2 ;
39276 int arg3 ;
39277 wxString *arg4 = 0 ;
39278 wxString const &arg5_defvalue = wxPyEmptyString ;
39279 wxString *arg5 = (wxString *) &arg5_defvalue ;
39280 wxMenuItem *result = 0 ;
39281 void *argp1 = 0 ;
39282 int res1 = 0 ;
39283 size_t val2 ;
39284 int ecode2 = 0 ;
39285 int val3 ;
39286 int ecode3 = 0 ;
39287 bool temp4 = false ;
39288 bool temp5 = false ;
39289 PyObject * obj0 = 0 ;
39290 PyObject * obj1 = 0 ;
39291 PyObject * obj2 = 0 ;
39292 PyObject * obj3 = 0 ;
39293 PyObject * obj4 = 0 ;
39294 char * kwnames[] = {
39295 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39296 };
39297
39298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39300 if (!SWIG_IsOK(res1)) {
39301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39302 }
39303 arg1 = reinterpret_cast< wxMenu * >(argp1);
39304 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39305 if (!SWIG_IsOK(ecode2)) {
39306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39307 }
39308 arg2 = static_cast< size_t >(val2);
39309 ecode3 = SWIG_AsVal_int(obj2, &val3);
39310 if (!SWIG_IsOK(ecode3)) {
39311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39312 }
39313 arg3 = static_cast< int >(val3);
39314 {
39315 arg4 = wxString_in_helper(obj3);
39316 if (arg4 == NULL) SWIG_fail;
39317 temp4 = true;
39318 }
39319 if (obj4) {
39320 {
39321 arg5 = wxString_in_helper(obj4);
39322 if (arg5 == NULL) SWIG_fail;
39323 temp5 = true;
39324 }
39325 }
39326 {
39327 PyThreadState* __tstate = wxPyBeginAllowThreads();
39328 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 {
39333 resultobj = wxPyMake_wxObject(result, (bool)0);
39334 }
39335 {
39336 if (temp4)
39337 delete arg4;
39338 }
39339 {
39340 if (temp5)
39341 delete arg5;
39342 }
39343 return resultobj;
39344 fail:
39345 {
39346 if (temp4)
39347 delete arg4;
39348 }
39349 {
39350 if (temp5)
39351 delete arg5;
39352 }
39353 return NULL;
39354 }
39355
39356
39357 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39358 PyObject *resultobj = 0;
39359 wxMenu *arg1 = (wxMenu *) 0 ;
39360 size_t arg2 ;
39361 int arg3 ;
39362 wxString *arg4 = 0 ;
39363 wxString const &arg5_defvalue = wxPyEmptyString ;
39364 wxString *arg5 = (wxString *) &arg5_defvalue ;
39365 wxMenuItem *result = 0 ;
39366 void *argp1 = 0 ;
39367 int res1 = 0 ;
39368 size_t val2 ;
39369 int ecode2 = 0 ;
39370 int val3 ;
39371 int ecode3 = 0 ;
39372 bool temp4 = false ;
39373 bool temp5 = false ;
39374 PyObject * obj0 = 0 ;
39375 PyObject * obj1 = 0 ;
39376 PyObject * obj2 = 0 ;
39377 PyObject * obj3 = 0 ;
39378 PyObject * obj4 = 0 ;
39379 char * kwnames[] = {
39380 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39381 };
39382
39383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39385 if (!SWIG_IsOK(res1)) {
39386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39387 }
39388 arg1 = reinterpret_cast< wxMenu * >(argp1);
39389 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39390 if (!SWIG_IsOK(ecode2)) {
39391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39392 }
39393 arg2 = static_cast< size_t >(val2);
39394 ecode3 = SWIG_AsVal_int(obj2, &val3);
39395 if (!SWIG_IsOK(ecode3)) {
39396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39397 }
39398 arg3 = static_cast< int >(val3);
39399 {
39400 arg4 = wxString_in_helper(obj3);
39401 if (arg4 == NULL) SWIG_fail;
39402 temp4 = true;
39403 }
39404 if (obj4) {
39405 {
39406 arg5 = wxString_in_helper(obj4);
39407 if (arg5 == NULL) SWIG_fail;
39408 temp5 = true;
39409 }
39410 }
39411 {
39412 PyThreadState* __tstate = wxPyBeginAllowThreads();
39413 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39414 wxPyEndAllowThreads(__tstate);
39415 if (PyErr_Occurred()) SWIG_fail;
39416 }
39417 {
39418 resultobj = wxPyMake_wxObject(result, (bool)0);
39419 }
39420 {
39421 if (temp4)
39422 delete arg4;
39423 }
39424 {
39425 if (temp5)
39426 delete arg5;
39427 }
39428 return resultobj;
39429 fail:
39430 {
39431 if (temp4)
39432 delete arg4;
39433 }
39434 {
39435 if (temp5)
39436 delete arg5;
39437 }
39438 return NULL;
39439 }
39440
39441
39442 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39443 PyObject *resultobj = 0;
39444 wxMenu *arg1 = (wxMenu *) 0 ;
39445 size_t arg2 ;
39446 int arg3 ;
39447 wxString *arg4 = 0 ;
39448 wxMenu *arg5 = (wxMenu *) 0 ;
39449 wxString const &arg6_defvalue = wxPyEmptyString ;
39450 wxString *arg6 = (wxString *) &arg6_defvalue ;
39451 wxMenuItem *result = 0 ;
39452 void *argp1 = 0 ;
39453 int res1 = 0 ;
39454 size_t val2 ;
39455 int ecode2 = 0 ;
39456 int val3 ;
39457 int ecode3 = 0 ;
39458 bool temp4 = false ;
39459 void *argp5 = 0 ;
39460 int res5 = 0 ;
39461 bool temp6 = false ;
39462 PyObject * obj0 = 0 ;
39463 PyObject * obj1 = 0 ;
39464 PyObject * obj2 = 0 ;
39465 PyObject * obj3 = 0 ;
39466 PyObject * obj4 = 0 ;
39467 PyObject * obj5 = 0 ;
39468 char * kwnames[] = {
39469 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39470 };
39471
39472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39474 if (!SWIG_IsOK(res1)) {
39475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39476 }
39477 arg1 = reinterpret_cast< wxMenu * >(argp1);
39478 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39479 if (!SWIG_IsOK(ecode2)) {
39480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39481 }
39482 arg2 = static_cast< size_t >(val2);
39483 ecode3 = SWIG_AsVal_int(obj2, &val3);
39484 if (!SWIG_IsOK(ecode3)) {
39485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39486 }
39487 arg3 = static_cast< int >(val3);
39488 {
39489 arg4 = wxString_in_helper(obj3);
39490 if (arg4 == NULL) SWIG_fail;
39491 temp4 = true;
39492 }
39493 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39494 if (!SWIG_IsOK(res5)) {
39495 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39496 }
39497 arg5 = reinterpret_cast< wxMenu * >(argp5);
39498 if (obj5) {
39499 {
39500 arg6 = wxString_in_helper(obj5);
39501 if (arg6 == NULL) SWIG_fail;
39502 temp6 = true;
39503 }
39504 }
39505 {
39506 PyThreadState* __tstate = wxPyBeginAllowThreads();
39507 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39508 wxPyEndAllowThreads(__tstate);
39509 if (PyErr_Occurred()) SWIG_fail;
39510 }
39511 {
39512 resultobj = wxPyMake_wxObject(result, (bool)0);
39513 }
39514 {
39515 if (temp4)
39516 delete arg4;
39517 }
39518 {
39519 if (temp6)
39520 delete arg6;
39521 }
39522 return resultobj;
39523 fail:
39524 {
39525 if (temp4)
39526 delete arg4;
39527 }
39528 {
39529 if (temp6)
39530 delete arg6;
39531 }
39532 return NULL;
39533 }
39534
39535
39536 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39537 PyObject *resultobj = 0;
39538 wxMenu *arg1 = (wxMenu *) 0 ;
39539 int arg2 ;
39540 wxString *arg3 = 0 ;
39541 wxString const &arg4_defvalue = wxPyEmptyString ;
39542 wxString *arg4 = (wxString *) &arg4_defvalue ;
39543 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39544 wxMenuItem *result = 0 ;
39545 void *argp1 = 0 ;
39546 int res1 = 0 ;
39547 int val2 ;
39548 int ecode2 = 0 ;
39549 bool temp3 = false ;
39550 bool temp4 = false ;
39551 int val5 ;
39552 int ecode5 = 0 ;
39553 PyObject * obj0 = 0 ;
39554 PyObject * obj1 = 0 ;
39555 PyObject * obj2 = 0 ;
39556 PyObject * obj3 = 0 ;
39557 PyObject * obj4 = 0 ;
39558 char * kwnames[] = {
39559 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39560 };
39561
39562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39564 if (!SWIG_IsOK(res1)) {
39565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39566 }
39567 arg1 = reinterpret_cast< wxMenu * >(argp1);
39568 ecode2 = SWIG_AsVal_int(obj1, &val2);
39569 if (!SWIG_IsOK(ecode2)) {
39570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39571 }
39572 arg2 = static_cast< int >(val2);
39573 {
39574 arg3 = wxString_in_helper(obj2);
39575 if (arg3 == NULL) SWIG_fail;
39576 temp3 = true;
39577 }
39578 if (obj3) {
39579 {
39580 arg4 = wxString_in_helper(obj3);
39581 if (arg4 == NULL) SWIG_fail;
39582 temp4 = true;
39583 }
39584 }
39585 if (obj4) {
39586 ecode5 = SWIG_AsVal_int(obj4, &val5);
39587 if (!SWIG_IsOK(ecode5)) {
39588 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39589 }
39590 arg5 = static_cast< wxItemKind >(val5);
39591 }
39592 {
39593 PyThreadState* __tstate = wxPyBeginAllowThreads();
39594 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39595 wxPyEndAllowThreads(__tstate);
39596 if (PyErr_Occurred()) SWIG_fail;
39597 }
39598 {
39599 resultobj = wxPyMake_wxObject(result, (bool)0);
39600 }
39601 {
39602 if (temp3)
39603 delete arg3;
39604 }
39605 {
39606 if (temp4)
39607 delete arg4;
39608 }
39609 return resultobj;
39610 fail:
39611 {
39612 if (temp3)
39613 delete arg3;
39614 }
39615 {
39616 if (temp4)
39617 delete arg4;
39618 }
39619 return NULL;
39620 }
39621
39622
39623 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39624 PyObject *resultobj = 0;
39625 wxMenu *arg1 = (wxMenu *) 0 ;
39626 wxMenuItem *result = 0 ;
39627 void *argp1 = 0 ;
39628 int res1 = 0 ;
39629 PyObject *swig_obj[1] ;
39630
39631 if (!args) SWIG_fail;
39632 swig_obj[0] = args;
39633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39634 if (!SWIG_IsOK(res1)) {
39635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39636 }
39637 arg1 = reinterpret_cast< wxMenu * >(argp1);
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 result = (wxMenuItem *)(arg1)->PrependSeparator();
39641 wxPyEndAllowThreads(__tstate);
39642 if (PyErr_Occurred()) SWIG_fail;
39643 }
39644 {
39645 resultobj = wxPyMake_wxObject(result, (bool)0);
39646 }
39647 return resultobj;
39648 fail:
39649 return NULL;
39650 }
39651
39652
39653 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39654 PyObject *resultobj = 0;
39655 wxMenu *arg1 = (wxMenu *) 0 ;
39656 int arg2 ;
39657 wxString *arg3 = 0 ;
39658 wxString const &arg4_defvalue = wxPyEmptyString ;
39659 wxString *arg4 = (wxString *) &arg4_defvalue ;
39660 wxMenuItem *result = 0 ;
39661 void *argp1 = 0 ;
39662 int res1 = 0 ;
39663 int val2 ;
39664 int ecode2 = 0 ;
39665 bool temp3 = false ;
39666 bool temp4 = false ;
39667 PyObject * obj0 = 0 ;
39668 PyObject * obj1 = 0 ;
39669 PyObject * obj2 = 0 ;
39670 PyObject * obj3 = 0 ;
39671 char * kwnames[] = {
39672 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39673 };
39674
39675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39677 if (!SWIG_IsOK(res1)) {
39678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39679 }
39680 arg1 = reinterpret_cast< wxMenu * >(argp1);
39681 ecode2 = SWIG_AsVal_int(obj1, &val2);
39682 if (!SWIG_IsOK(ecode2)) {
39683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39684 }
39685 arg2 = static_cast< int >(val2);
39686 {
39687 arg3 = wxString_in_helper(obj2);
39688 if (arg3 == NULL) SWIG_fail;
39689 temp3 = true;
39690 }
39691 if (obj3) {
39692 {
39693 arg4 = wxString_in_helper(obj3);
39694 if (arg4 == NULL) SWIG_fail;
39695 temp4 = true;
39696 }
39697 }
39698 {
39699 PyThreadState* __tstate = wxPyBeginAllowThreads();
39700 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39701 wxPyEndAllowThreads(__tstate);
39702 if (PyErr_Occurred()) SWIG_fail;
39703 }
39704 {
39705 resultobj = wxPyMake_wxObject(result, (bool)0);
39706 }
39707 {
39708 if (temp3)
39709 delete arg3;
39710 }
39711 {
39712 if (temp4)
39713 delete arg4;
39714 }
39715 return resultobj;
39716 fail:
39717 {
39718 if (temp3)
39719 delete arg3;
39720 }
39721 {
39722 if (temp4)
39723 delete arg4;
39724 }
39725 return NULL;
39726 }
39727
39728
39729 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39730 PyObject *resultobj = 0;
39731 wxMenu *arg1 = (wxMenu *) 0 ;
39732 int arg2 ;
39733 wxString *arg3 = 0 ;
39734 wxString const &arg4_defvalue = wxPyEmptyString ;
39735 wxString *arg4 = (wxString *) &arg4_defvalue ;
39736 wxMenuItem *result = 0 ;
39737 void *argp1 = 0 ;
39738 int res1 = 0 ;
39739 int val2 ;
39740 int ecode2 = 0 ;
39741 bool temp3 = false ;
39742 bool temp4 = false ;
39743 PyObject * obj0 = 0 ;
39744 PyObject * obj1 = 0 ;
39745 PyObject * obj2 = 0 ;
39746 PyObject * obj3 = 0 ;
39747 char * kwnames[] = {
39748 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39749 };
39750
39751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39753 if (!SWIG_IsOK(res1)) {
39754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39755 }
39756 arg1 = reinterpret_cast< wxMenu * >(argp1);
39757 ecode2 = SWIG_AsVal_int(obj1, &val2);
39758 if (!SWIG_IsOK(ecode2)) {
39759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39760 }
39761 arg2 = static_cast< int >(val2);
39762 {
39763 arg3 = wxString_in_helper(obj2);
39764 if (arg3 == NULL) SWIG_fail;
39765 temp3 = true;
39766 }
39767 if (obj3) {
39768 {
39769 arg4 = wxString_in_helper(obj3);
39770 if (arg4 == NULL) SWIG_fail;
39771 temp4 = true;
39772 }
39773 }
39774 {
39775 PyThreadState* __tstate = wxPyBeginAllowThreads();
39776 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39777 wxPyEndAllowThreads(__tstate);
39778 if (PyErr_Occurred()) SWIG_fail;
39779 }
39780 {
39781 resultobj = wxPyMake_wxObject(result, (bool)0);
39782 }
39783 {
39784 if (temp3)
39785 delete arg3;
39786 }
39787 {
39788 if (temp4)
39789 delete arg4;
39790 }
39791 return resultobj;
39792 fail:
39793 {
39794 if (temp3)
39795 delete arg3;
39796 }
39797 {
39798 if (temp4)
39799 delete arg4;
39800 }
39801 return NULL;
39802 }
39803
39804
39805 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39806 PyObject *resultobj = 0;
39807 wxMenu *arg1 = (wxMenu *) 0 ;
39808 int arg2 ;
39809 wxString *arg3 = 0 ;
39810 wxMenu *arg4 = (wxMenu *) 0 ;
39811 wxString const &arg5_defvalue = wxPyEmptyString ;
39812 wxString *arg5 = (wxString *) &arg5_defvalue ;
39813 wxMenuItem *result = 0 ;
39814 void *argp1 = 0 ;
39815 int res1 = 0 ;
39816 int val2 ;
39817 int ecode2 = 0 ;
39818 bool temp3 = false ;
39819 void *argp4 = 0 ;
39820 int res4 = 0 ;
39821 bool temp5 = false ;
39822 PyObject * obj0 = 0 ;
39823 PyObject * obj1 = 0 ;
39824 PyObject * obj2 = 0 ;
39825 PyObject * obj3 = 0 ;
39826 PyObject * obj4 = 0 ;
39827 char * kwnames[] = {
39828 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39829 };
39830
39831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39833 if (!SWIG_IsOK(res1)) {
39834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39835 }
39836 arg1 = reinterpret_cast< wxMenu * >(argp1);
39837 ecode2 = SWIG_AsVal_int(obj1, &val2);
39838 if (!SWIG_IsOK(ecode2)) {
39839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39840 }
39841 arg2 = static_cast< int >(val2);
39842 {
39843 arg3 = wxString_in_helper(obj2);
39844 if (arg3 == NULL) SWIG_fail;
39845 temp3 = true;
39846 }
39847 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39848 if (!SWIG_IsOK(res4)) {
39849 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39850 }
39851 arg4 = reinterpret_cast< wxMenu * >(argp4);
39852 if (obj4) {
39853 {
39854 arg5 = wxString_in_helper(obj4);
39855 if (arg5 == NULL) SWIG_fail;
39856 temp5 = true;
39857 }
39858 }
39859 {
39860 PyThreadState* __tstate = wxPyBeginAllowThreads();
39861 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39862 wxPyEndAllowThreads(__tstate);
39863 if (PyErr_Occurred()) SWIG_fail;
39864 }
39865 {
39866 resultobj = wxPyMake_wxObject(result, (bool)0);
39867 }
39868 {
39869 if (temp3)
39870 delete arg3;
39871 }
39872 {
39873 if (temp5)
39874 delete arg5;
39875 }
39876 return resultobj;
39877 fail:
39878 {
39879 if (temp3)
39880 delete arg3;
39881 }
39882 {
39883 if (temp5)
39884 delete arg5;
39885 }
39886 return NULL;
39887 }
39888
39889
39890 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39891 PyObject *resultobj = 0;
39892 wxMenu *arg1 = (wxMenu *) 0 ;
39893 int arg2 ;
39894 wxMenuItem *result = 0 ;
39895 void *argp1 = 0 ;
39896 int res1 = 0 ;
39897 int val2 ;
39898 int ecode2 = 0 ;
39899 PyObject * obj0 = 0 ;
39900 PyObject * obj1 = 0 ;
39901 char * kwnames[] = {
39902 (char *) "self",(char *) "id", NULL
39903 };
39904
39905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39907 if (!SWIG_IsOK(res1)) {
39908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39909 }
39910 arg1 = reinterpret_cast< wxMenu * >(argp1);
39911 ecode2 = SWIG_AsVal_int(obj1, &val2);
39912 if (!SWIG_IsOK(ecode2)) {
39913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39914 }
39915 arg2 = static_cast< int >(val2);
39916 {
39917 PyThreadState* __tstate = wxPyBeginAllowThreads();
39918 result = (wxMenuItem *)(arg1)->Remove(arg2);
39919 wxPyEndAllowThreads(__tstate);
39920 if (PyErr_Occurred()) SWIG_fail;
39921 }
39922 {
39923 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39924 }
39925 return resultobj;
39926 fail:
39927 return NULL;
39928 }
39929
39930
39931 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39932 PyObject *resultobj = 0;
39933 wxMenu *arg1 = (wxMenu *) 0 ;
39934 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39935 wxMenuItem *result = 0 ;
39936 void *argp1 = 0 ;
39937 int res1 = 0 ;
39938 void *argp2 = 0 ;
39939 int res2 = 0 ;
39940 PyObject * obj0 = 0 ;
39941 PyObject * obj1 = 0 ;
39942 char * kwnames[] = {
39943 (char *) "self",(char *) "item", NULL
39944 };
39945
39946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39948 if (!SWIG_IsOK(res1)) {
39949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39950 }
39951 arg1 = reinterpret_cast< wxMenu * >(argp1);
39952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39953 if (!SWIG_IsOK(res2)) {
39954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39955 }
39956 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39957 {
39958 PyThreadState* __tstate = wxPyBeginAllowThreads();
39959 result = (wxMenuItem *)(arg1)->Remove(arg2);
39960 wxPyEndAllowThreads(__tstate);
39961 if (PyErr_Occurred()) SWIG_fail;
39962 }
39963 {
39964 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39965 }
39966 return resultobj;
39967 fail:
39968 return NULL;
39969 }
39970
39971
39972 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39973 PyObject *resultobj = 0;
39974 wxMenu *arg1 = (wxMenu *) 0 ;
39975 int arg2 ;
39976 bool result;
39977 void *argp1 = 0 ;
39978 int res1 = 0 ;
39979 int val2 ;
39980 int ecode2 = 0 ;
39981 PyObject * obj0 = 0 ;
39982 PyObject * obj1 = 0 ;
39983 char * kwnames[] = {
39984 (char *) "self",(char *) "id", NULL
39985 };
39986
39987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39989 if (!SWIG_IsOK(res1)) {
39990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39991 }
39992 arg1 = reinterpret_cast< wxMenu * >(argp1);
39993 ecode2 = SWIG_AsVal_int(obj1, &val2);
39994 if (!SWIG_IsOK(ecode2)) {
39995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39996 }
39997 arg2 = static_cast< int >(val2);
39998 {
39999 PyThreadState* __tstate = wxPyBeginAllowThreads();
40000 result = (bool)(arg1)->Delete(arg2);
40001 wxPyEndAllowThreads(__tstate);
40002 if (PyErr_Occurred()) SWIG_fail;
40003 }
40004 {
40005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40006 }
40007 return resultobj;
40008 fail:
40009 return NULL;
40010 }
40011
40012
40013 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40014 PyObject *resultobj = 0;
40015 wxMenu *arg1 = (wxMenu *) 0 ;
40016 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40017 bool result;
40018 void *argp1 = 0 ;
40019 int res1 = 0 ;
40020 void *argp2 = 0 ;
40021 int res2 = 0 ;
40022 PyObject * obj0 = 0 ;
40023 PyObject * obj1 = 0 ;
40024 char * kwnames[] = {
40025 (char *) "self",(char *) "item", NULL
40026 };
40027
40028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40030 if (!SWIG_IsOK(res1)) {
40031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40032 }
40033 arg1 = reinterpret_cast< wxMenu * >(argp1);
40034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40035 if (!SWIG_IsOK(res2)) {
40036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40037 }
40038 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40039 {
40040 PyThreadState* __tstate = wxPyBeginAllowThreads();
40041 result = (bool)(arg1)->Delete(arg2);
40042 wxPyEndAllowThreads(__tstate);
40043 if (PyErr_Occurred()) SWIG_fail;
40044 }
40045 {
40046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40047 }
40048 return resultobj;
40049 fail:
40050 return NULL;
40051 }
40052
40053
40054 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40055 PyObject *resultobj = 0;
40056 wxMenu *arg1 = (wxMenu *) 0 ;
40057 void *argp1 = 0 ;
40058 int res1 = 0 ;
40059 PyObject *swig_obj[1] ;
40060
40061 if (!args) SWIG_fail;
40062 swig_obj[0] = args;
40063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40064 if (!SWIG_IsOK(res1)) {
40065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40066 }
40067 arg1 = reinterpret_cast< wxMenu * >(argp1);
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 wxMenu_Destroy(arg1);
40071 wxPyEndAllowThreads(__tstate);
40072 if (PyErr_Occurred()) SWIG_fail;
40073 }
40074 resultobj = SWIG_Py_Void();
40075 return resultobj;
40076 fail:
40077 return NULL;
40078 }
40079
40080
40081 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40082 PyObject *resultobj = 0;
40083 wxMenu *arg1 = (wxMenu *) 0 ;
40084 int arg2 ;
40085 bool result;
40086 void *argp1 = 0 ;
40087 int res1 = 0 ;
40088 int val2 ;
40089 int ecode2 = 0 ;
40090 PyObject * obj0 = 0 ;
40091 PyObject * obj1 = 0 ;
40092 char * kwnames[] = {
40093 (char *) "self",(char *) "id", NULL
40094 };
40095
40096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40098 if (!SWIG_IsOK(res1)) {
40099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40100 }
40101 arg1 = reinterpret_cast< wxMenu * >(argp1);
40102 ecode2 = SWIG_AsVal_int(obj1, &val2);
40103 if (!SWIG_IsOK(ecode2)) {
40104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40105 }
40106 arg2 = static_cast< int >(val2);
40107 {
40108 PyThreadState* __tstate = wxPyBeginAllowThreads();
40109 result = (bool)(arg1)->Destroy(arg2);
40110 wxPyEndAllowThreads(__tstate);
40111 if (PyErr_Occurred()) SWIG_fail;
40112 }
40113 {
40114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40115 }
40116 return resultobj;
40117 fail:
40118 return NULL;
40119 }
40120
40121
40122 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40123 PyObject *resultobj = 0;
40124 wxMenu *arg1 = (wxMenu *) 0 ;
40125 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40126 bool result;
40127 void *argp1 = 0 ;
40128 int res1 = 0 ;
40129 void *argp2 = 0 ;
40130 int res2 = 0 ;
40131 PyObject * obj0 = 0 ;
40132 PyObject * obj1 = 0 ;
40133 char * kwnames[] = {
40134 (char *) "self",(char *) "item", NULL
40135 };
40136
40137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40139 if (!SWIG_IsOK(res1)) {
40140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40141 }
40142 arg1 = reinterpret_cast< wxMenu * >(argp1);
40143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40144 if (!SWIG_IsOK(res2)) {
40145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40146 }
40147 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40148 {
40149 PyThreadState* __tstate = wxPyBeginAllowThreads();
40150 result = (bool)(arg1)->Destroy(arg2);
40151 wxPyEndAllowThreads(__tstate);
40152 if (PyErr_Occurred()) SWIG_fail;
40153 }
40154 {
40155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40156 }
40157 return resultobj;
40158 fail:
40159 return NULL;
40160 }
40161
40162
40163 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40164 PyObject *resultobj = 0;
40165 wxMenu *arg1 = (wxMenu *) 0 ;
40166 size_t result;
40167 void *argp1 = 0 ;
40168 int res1 = 0 ;
40169 PyObject *swig_obj[1] ;
40170
40171 if (!args) SWIG_fail;
40172 swig_obj[0] = args;
40173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40174 if (!SWIG_IsOK(res1)) {
40175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40176 }
40177 arg1 = reinterpret_cast< wxMenu * >(argp1);
40178 {
40179 PyThreadState* __tstate = wxPyBeginAllowThreads();
40180 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40181 wxPyEndAllowThreads(__tstate);
40182 if (PyErr_Occurred()) SWIG_fail;
40183 }
40184 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40185 return resultobj;
40186 fail:
40187 return NULL;
40188 }
40189
40190
40191 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40192 PyObject *resultobj = 0;
40193 wxMenu *arg1 = (wxMenu *) 0 ;
40194 PyObject *result = 0 ;
40195 void *argp1 = 0 ;
40196 int res1 = 0 ;
40197 PyObject *swig_obj[1] ;
40198
40199 if (!args) SWIG_fail;
40200 swig_obj[0] = args;
40201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40202 if (!SWIG_IsOK(res1)) {
40203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40204 }
40205 arg1 = reinterpret_cast< wxMenu * >(argp1);
40206 {
40207 PyThreadState* __tstate = wxPyBeginAllowThreads();
40208 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40209 wxPyEndAllowThreads(__tstate);
40210 if (PyErr_Occurred()) SWIG_fail;
40211 }
40212 resultobj = result;
40213 return resultobj;
40214 fail:
40215 return NULL;
40216 }
40217
40218
40219 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40220 PyObject *resultobj = 0;
40221 wxMenu *arg1 = (wxMenu *) 0 ;
40222 wxString *arg2 = 0 ;
40223 int result;
40224 void *argp1 = 0 ;
40225 int res1 = 0 ;
40226 bool temp2 = false ;
40227 PyObject * obj0 = 0 ;
40228 PyObject * obj1 = 0 ;
40229 char * kwnames[] = {
40230 (char *) "self",(char *) "item", NULL
40231 };
40232
40233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40235 if (!SWIG_IsOK(res1)) {
40236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40237 }
40238 arg1 = reinterpret_cast< wxMenu * >(argp1);
40239 {
40240 arg2 = wxString_in_helper(obj1);
40241 if (arg2 == NULL) SWIG_fail;
40242 temp2 = true;
40243 }
40244 {
40245 PyThreadState* __tstate = wxPyBeginAllowThreads();
40246 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40247 wxPyEndAllowThreads(__tstate);
40248 if (PyErr_Occurred()) SWIG_fail;
40249 }
40250 resultobj = SWIG_From_int(static_cast< int >(result));
40251 {
40252 if (temp2)
40253 delete arg2;
40254 }
40255 return resultobj;
40256 fail:
40257 {
40258 if (temp2)
40259 delete arg2;
40260 }
40261 return NULL;
40262 }
40263
40264
40265 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40266 PyObject *resultobj = 0;
40267 wxMenu *arg1 = (wxMenu *) 0 ;
40268 int arg2 ;
40269 wxMenuItem *result = 0 ;
40270 void *argp1 = 0 ;
40271 int res1 = 0 ;
40272 int val2 ;
40273 int ecode2 = 0 ;
40274 PyObject * obj0 = 0 ;
40275 PyObject * obj1 = 0 ;
40276 char * kwnames[] = {
40277 (char *) "self",(char *) "id", NULL
40278 };
40279
40280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40282 if (!SWIG_IsOK(res1)) {
40283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40284 }
40285 arg1 = reinterpret_cast< wxMenu * >(argp1);
40286 ecode2 = SWIG_AsVal_int(obj1, &val2);
40287 if (!SWIG_IsOK(ecode2)) {
40288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40289 }
40290 arg2 = static_cast< int >(val2);
40291 {
40292 PyThreadState* __tstate = wxPyBeginAllowThreads();
40293 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40294 wxPyEndAllowThreads(__tstate);
40295 if (PyErr_Occurred()) SWIG_fail;
40296 }
40297 {
40298 resultobj = wxPyMake_wxObject(result, (bool)0);
40299 }
40300 return resultobj;
40301 fail:
40302 return NULL;
40303 }
40304
40305
40306 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40307 PyObject *resultobj = 0;
40308 wxMenu *arg1 = (wxMenu *) 0 ;
40309 size_t arg2 ;
40310 wxMenuItem *result = 0 ;
40311 void *argp1 = 0 ;
40312 int res1 = 0 ;
40313 size_t val2 ;
40314 int ecode2 = 0 ;
40315 PyObject * obj0 = 0 ;
40316 PyObject * obj1 = 0 ;
40317 char * kwnames[] = {
40318 (char *) "self",(char *) "position", NULL
40319 };
40320
40321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40323 if (!SWIG_IsOK(res1)) {
40324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40325 }
40326 arg1 = reinterpret_cast< wxMenu * >(argp1);
40327 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40328 if (!SWIG_IsOK(ecode2)) {
40329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40330 }
40331 arg2 = static_cast< size_t >(val2);
40332 {
40333 PyThreadState* __tstate = wxPyBeginAllowThreads();
40334 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40335 wxPyEndAllowThreads(__tstate);
40336 if (PyErr_Occurred()) SWIG_fail;
40337 }
40338 {
40339 resultobj = wxPyMake_wxObject(result, (bool)0);
40340 }
40341 return resultobj;
40342 fail:
40343 return NULL;
40344 }
40345
40346
40347 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40348 PyObject *resultobj = 0;
40349 wxMenu *arg1 = (wxMenu *) 0 ;
40350 int arg2 ;
40351 bool arg3 ;
40352 void *argp1 = 0 ;
40353 int res1 = 0 ;
40354 int val2 ;
40355 int ecode2 = 0 ;
40356 bool val3 ;
40357 int ecode3 = 0 ;
40358 PyObject * obj0 = 0 ;
40359 PyObject * obj1 = 0 ;
40360 PyObject * obj2 = 0 ;
40361 char * kwnames[] = {
40362 (char *) "self",(char *) "id",(char *) "enable", NULL
40363 };
40364
40365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40367 if (!SWIG_IsOK(res1)) {
40368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40369 }
40370 arg1 = reinterpret_cast< wxMenu * >(argp1);
40371 ecode2 = SWIG_AsVal_int(obj1, &val2);
40372 if (!SWIG_IsOK(ecode2)) {
40373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40374 }
40375 arg2 = static_cast< int >(val2);
40376 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40377 if (!SWIG_IsOK(ecode3)) {
40378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40379 }
40380 arg3 = static_cast< bool >(val3);
40381 {
40382 PyThreadState* __tstate = wxPyBeginAllowThreads();
40383 (arg1)->Enable(arg2,arg3);
40384 wxPyEndAllowThreads(__tstate);
40385 if (PyErr_Occurred()) SWIG_fail;
40386 }
40387 resultobj = SWIG_Py_Void();
40388 return resultobj;
40389 fail:
40390 return NULL;
40391 }
40392
40393
40394 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40395 PyObject *resultobj = 0;
40396 wxMenu *arg1 = (wxMenu *) 0 ;
40397 int arg2 ;
40398 bool result;
40399 void *argp1 = 0 ;
40400 int res1 = 0 ;
40401 int val2 ;
40402 int ecode2 = 0 ;
40403 PyObject * obj0 = 0 ;
40404 PyObject * obj1 = 0 ;
40405 char * kwnames[] = {
40406 (char *) "self",(char *) "id", NULL
40407 };
40408
40409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40411 if (!SWIG_IsOK(res1)) {
40412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40413 }
40414 arg1 = reinterpret_cast< wxMenu * >(argp1);
40415 ecode2 = SWIG_AsVal_int(obj1, &val2);
40416 if (!SWIG_IsOK(ecode2)) {
40417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40418 }
40419 arg2 = static_cast< int >(val2);
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 {
40427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40428 }
40429 return resultobj;
40430 fail:
40431 return NULL;
40432 }
40433
40434
40435 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40436 PyObject *resultobj = 0;
40437 wxMenu *arg1 = (wxMenu *) 0 ;
40438 int arg2 ;
40439 bool arg3 ;
40440 void *argp1 = 0 ;
40441 int res1 = 0 ;
40442 int val2 ;
40443 int ecode2 = 0 ;
40444 bool val3 ;
40445 int ecode3 = 0 ;
40446 PyObject * obj0 = 0 ;
40447 PyObject * obj1 = 0 ;
40448 PyObject * obj2 = 0 ;
40449 char * kwnames[] = {
40450 (char *) "self",(char *) "id",(char *) "check", NULL
40451 };
40452
40453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40455 if (!SWIG_IsOK(res1)) {
40456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40457 }
40458 arg1 = reinterpret_cast< wxMenu * >(argp1);
40459 ecode2 = SWIG_AsVal_int(obj1, &val2);
40460 if (!SWIG_IsOK(ecode2)) {
40461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40462 }
40463 arg2 = static_cast< int >(val2);
40464 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40465 if (!SWIG_IsOK(ecode3)) {
40466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40467 }
40468 arg3 = static_cast< bool >(val3);
40469 {
40470 PyThreadState* __tstate = wxPyBeginAllowThreads();
40471 (arg1)->Check(arg2,arg3);
40472 wxPyEndAllowThreads(__tstate);
40473 if (PyErr_Occurred()) SWIG_fail;
40474 }
40475 resultobj = SWIG_Py_Void();
40476 return resultobj;
40477 fail:
40478 return NULL;
40479 }
40480
40481
40482 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40483 PyObject *resultobj = 0;
40484 wxMenu *arg1 = (wxMenu *) 0 ;
40485 int arg2 ;
40486 bool result;
40487 void *argp1 = 0 ;
40488 int res1 = 0 ;
40489 int val2 ;
40490 int ecode2 = 0 ;
40491 PyObject * obj0 = 0 ;
40492 PyObject * obj1 = 0 ;
40493 char * kwnames[] = {
40494 (char *) "self",(char *) "id", NULL
40495 };
40496
40497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40499 if (!SWIG_IsOK(res1)) {
40500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40501 }
40502 arg1 = reinterpret_cast< wxMenu * >(argp1);
40503 ecode2 = SWIG_AsVal_int(obj1, &val2);
40504 if (!SWIG_IsOK(ecode2)) {
40505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40506 }
40507 arg2 = static_cast< int >(val2);
40508 {
40509 PyThreadState* __tstate = wxPyBeginAllowThreads();
40510 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40511 wxPyEndAllowThreads(__tstate);
40512 if (PyErr_Occurred()) SWIG_fail;
40513 }
40514 {
40515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40516 }
40517 return resultobj;
40518 fail:
40519 return NULL;
40520 }
40521
40522
40523 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40524 PyObject *resultobj = 0;
40525 wxMenu *arg1 = (wxMenu *) 0 ;
40526 int arg2 ;
40527 wxString *arg3 = 0 ;
40528 void *argp1 = 0 ;
40529 int res1 = 0 ;
40530 int val2 ;
40531 int ecode2 = 0 ;
40532 bool temp3 = false ;
40533 PyObject * obj0 = 0 ;
40534 PyObject * obj1 = 0 ;
40535 PyObject * obj2 = 0 ;
40536 char * kwnames[] = {
40537 (char *) "self",(char *) "id",(char *) "label", NULL
40538 };
40539
40540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40542 if (!SWIG_IsOK(res1)) {
40543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40544 }
40545 arg1 = reinterpret_cast< wxMenu * >(argp1);
40546 ecode2 = SWIG_AsVal_int(obj1, &val2);
40547 if (!SWIG_IsOK(ecode2)) {
40548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40549 }
40550 arg2 = static_cast< int >(val2);
40551 {
40552 arg3 = wxString_in_helper(obj2);
40553 if (arg3 == NULL) SWIG_fail;
40554 temp3 = true;
40555 }
40556 {
40557 PyThreadState* __tstate = wxPyBeginAllowThreads();
40558 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40559 wxPyEndAllowThreads(__tstate);
40560 if (PyErr_Occurred()) SWIG_fail;
40561 }
40562 resultobj = SWIG_Py_Void();
40563 {
40564 if (temp3)
40565 delete arg3;
40566 }
40567 return resultobj;
40568 fail:
40569 {
40570 if (temp3)
40571 delete arg3;
40572 }
40573 return NULL;
40574 }
40575
40576
40577 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40578 PyObject *resultobj = 0;
40579 wxMenu *arg1 = (wxMenu *) 0 ;
40580 int arg2 ;
40581 wxString result;
40582 void *argp1 = 0 ;
40583 int res1 = 0 ;
40584 int val2 ;
40585 int ecode2 = 0 ;
40586 PyObject * obj0 = 0 ;
40587 PyObject * obj1 = 0 ;
40588 char * kwnames[] = {
40589 (char *) "self",(char *) "id", NULL
40590 };
40591
40592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40594 if (!SWIG_IsOK(res1)) {
40595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40596 }
40597 arg1 = reinterpret_cast< wxMenu * >(argp1);
40598 ecode2 = SWIG_AsVal_int(obj1, &val2);
40599 if (!SWIG_IsOK(ecode2)) {
40600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40601 }
40602 arg2 = static_cast< int >(val2);
40603 {
40604 PyThreadState* __tstate = wxPyBeginAllowThreads();
40605 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40606 wxPyEndAllowThreads(__tstate);
40607 if (PyErr_Occurred()) SWIG_fail;
40608 }
40609 {
40610 #if wxUSE_UNICODE
40611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40612 #else
40613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40614 #endif
40615 }
40616 return resultobj;
40617 fail:
40618 return NULL;
40619 }
40620
40621
40622 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40623 PyObject *resultobj = 0;
40624 wxMenu *arg1 = (wxMenu *) 0 ;
40625 int arg2 ;
40626 wxString *arg3 = 0 ;
40627 void *argp1 = 0 ;
40628 int res1 = 0 ;
40629 int val2 ;
40630 int ecode2 = 0 ;
40631 bool temp3 = false ;
40632 PyObject * obj0 = 0 ;
40633 PyObject * obj1 = 0 ;
40634 PyObject * obj2 = 0 ;
40635 char * kwnames[] = {
40636 (char *) "self",(char *) "id",(char *) "helpString", NULL
40637 };
40638
40639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40641 if (!SWIG_IsOK(res1)) {
40642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40643 }
40644 arg1 = reinterpret_cast< wxMenu * >(argp1);
40645 ecode2 = SWIG_AsVal_int(obj1, &val2);
40646 if (!SWIG_IsOK(ecode2)) {
40647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40648 }
40649 arg2 = static_cast< int >(val2);
40650 {
40651 arg3 = wxString_in_helper(obj2);
40652 if (arg3 == NULL) SWIG_fail;
40653 temp3 = true;
40654 }
40655 {
40656 PyThreadState* __tstate = wxPyBeginAllowThreads();
40657 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40658 wxPyEndAllowThreads(__tstate);
40659 if (PyErr_Occurred()) SWIG_fail;
40660 }
40661 resultobj = SWIG_Py_Void();
40662 {
40663 if (temp3)
40664 delete arg3;
40665 }
40666 return resultobj;
40667 fail:
40668 {
40669 if (temp3)
40670 delete arg3;
40671 }
40672 return NULL;
40673 }
40674
40675
40676 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40677 PyObject *resultobj = 0;
40678 wxMenu *arg1 = (wxMenu *) 0 ;
40679 int arg2 ;
40680 wxString result;
40681 void *argp1 = 0 ;
40682 int res1 = 0 ;
40683 int val2 ;
40684 int ecode2 = 0 ;
40685 PyObject * obj0 = 0 ;
40686 PyObject * obj1 = 0 ;
40687 char * kwnames[] = {
40688 (char *) "self",(char *) "id", NULL
40689 };
40690
40691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40693 if (!SWIG_IsOK(res1)) {
40694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40695 }
40696 arg1 = reinterpret_cast< wxMenu * >(argp1);
40697 ecode2 = SWIG_AsVal_int(obj1, &val2);
40698 if (!SWIG_IsOK(ecode2)) {
40699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40700 }
40701 arg2 = static_cast< int >(val2);
40702 {
40703 PyThreadState* __tstate = wxPyBeginAllowThreads();
40704 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40705 wxPyEndAllowThreads(__tstate);
40706 if (PyErr_Occurred()) SWIG_fail;
40707 }
40708 {
40709 #if wxUSE_UNICODE
40710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40711 #else
40712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40713 #endif
40714 }
40715 return resultobj;
40716 fail:
40717 return NULL;
40718 }
40719
40720
40721 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40722 PyObject *resultobj = 0;
40723 wxMenu *arg1 = (wxMenu *) 0 ;
40724 wxString *arg2 = 0 ;
40725 void *argp1 = 0 ;
40726 int res1 = 0 ;
40727 bool temp2 = false ;
40728 PyObject * obj0 = 0 ;
40729 PyObject * obj1 = 0 ;
40730 char * kwnames[] = {
40731 (char *) "self",(char *) "title", NULL
40732 };
40733
40734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40736 if (!SWIG_IsOK(res1)) {
40737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40738 }
40739 arg1 = reinterpret_cast< wxMenu * >(argp1);
40740 {
40741 arg2 = wxString_in_helper(obj1);
40742 if (arg2 == NULL) SWIG_fail;
40743 temp2 = true;
40744 }
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 (arg1)->SetTitle((wxString const &)*arg2);
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 resultobj = SWIG_Py_Void();
40752 {
40753 if (temp2)
40754 delete arg2;
40755 }
40756 return resultobj;
40757 fail:
40758 {
40759 if (temp2)
40760 delete arg2;
40761 }
40762 return NULL;
40763 }
40764
40765
40766 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40767 PyObject *resultobj = 0;
40768 wxMenu *arg1 = (wxMenu *) 0 ;
40769 wxString 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_wxMenu, 0 | 0 );
40777 if (!SWIG_IsOK(res1)) {
40778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40779 }
40780 arg1 = reinterpret_cast< wxMenu * >(argp1);
40781 {
40782 PyThreadState* __tstate = wxPyBeginAllowThreads();
40783 result = ((wxMenu const *)arg1)->GetTitle();
40784 wxPyEndAllowThreads(__tstate);
40785 if (PyErr_Occurred()) SWIG_fail;
40786 }
40787 {
40788 #if wxUSE_UNICODE
40789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40790 #else
40791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40792 #endif
40793 }
40794 return resultobj;
40795 fail:
40796 return NULL;
40797 }
40798
40799
40800 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40801 PyObject *resultobj = 0;
40802 wxMenu *arg1 = (wxMenu *) 0 ;
40803 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40804 void *argp1 = 0 ;
40805 int res1 = 0 ;
40806 void *argp2 = 0 ;
40807 int res2 = 0 ;
40808 PyObject * obj0 = 0 ;
40809 PyObject * obj1 = 0 ;
40810 char * kwnames[] = {
40811 (char *) "self",(char *) "handler", NULL
40812 };
40813
40814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40816 if (!SWIG_IsOK(res1)) {
40817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40818 }
40819 arg1 = reinterpret_cast< wxMenu * >(argp1);
40820 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40821 if (!SWIG_IsOK(res2)) {
40822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40823 }
40824 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 (arg1)->SetEventHandler(arg2);
40828 wxPyEndAllowThreads(__tstate);
40829 if (PyErr_Occurred()) SWIG_fail;
40830 }
40831 resultobj = SWIG_Py_Void();
40832 return resultobj;
40833 fail:
40834 return NULL;
40835 }
40836
40837
40838 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40839 PyObject *resultobj = 0;
40840 wxMenu *arg1 = (wxMenu *) 0 ;
40841 wxEvtHandler *result = 0 ;
40842 void *argp1 = 0 ;
40843 int res1 = 0 ;
40844 PyObject *swig_obj[1] ;
40845
40846 if (!args) SWIG_fail;
40847 swig_obj[0] = args;
40848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40849 if (!SWIG_IsOK(res1)) {
40850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40851 }
40852 arg1 = reinterpret_cast< wxMenu * >(argp1);
40853 {
40854 PyThreadState* __tstate = wxPyBeginAllowThreads();
40855 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40856 wxPyEndAllowThreads(__tstate);
40857 if (PyErr_Occurred()) SWIG_fail;
40858 }
40859 {
40860 resultobj = wxPyMake_wxObject(result, 0);
40861 }
40862 return resultobj;
40863 fail:
40864 return NULL;
40865 }
40866
40867
40868 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40869 PyObject *resultobj = 0;
40870 wxMenu *arg1 = (wxMenu *) 0 ;
40871 wxWindow *arg2 = (wxWindow *) 0 ;
40872 void *argp1 = 0 ;
40873 int res1 = 0 ;
40874 void *argp2 = 0 ;
40875 int res2 = 0 ;
40876 PyObject * obj0 = 0 ;
40877 PyObject * obj1 = 0 ;
40878 char * kwnames[] = {
40879 (char *) "self",(char *) "win", NULL
40880 };
40881
40882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40884 if (!SWIG_IsOK(res1)) {
40885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40886 }
40887 arg1 = reinterpret_cast< wxMenu * >(argp1);
40888 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40889 if (!SWIG_IsOK(res2)) {
40890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40891 }
40892 arg2 = reinterpret_cast< wxWindow * >(argp2);
40893 {
40894 PyThreadState* __tstate = wxPyBeginAllowThreads();
40895 (arg1)->SetInvokingWindow(arg2);
40896 wxPyEndAllowThreads(__tstate);
40897 if (PyErr_Occurred()) SWIG_fail;
40898 }
40899 resultobj = SWIG_Py_Void();
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40907 PyObject *resultobj = 0;
40908 wxMenu *arg1 = (wxMenu *) 0 ;
40909 wxWindow *result = 0 ;
40910 void *argp1 = 0 ;
40911 int res1 = 0 ;
40912 PyObject *swig_obj[1] ;
40913
40914 if (!args) SWIG_fail;
40915 swig_obj[0] = args;
40916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40917 if (!SWIG_IsOK(res1)) {
40918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40919 }
40920 arg1 = reinterpret_cast< wxMenu * >(argp1);
40921 {
40922 PyThreadState* __tstate = wxPyBeginAllowThreads();
40923 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40924 wxPyEndAllowThreads(__tstate);
40925 if (PyErr_Occurred()) SWIG_fail;
40926 }
40927 {
40928 resultobj = wxPyMake_wxObject(result, 0);
40929 }
40930 return resultobj;
40931 fail:
40932 return NULL;
40933 }
40934
40935
40936 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40937 PyObject *resultobj = 0;
40938 wxMenu *arg1 = (wxMenu *) 0 ;
40939 long result;
40940 void *argp1 = 0 ;
40941 int res1 = 0 ;
40942 PyObject *swig_obj[1] ;
40943
40944 if (!args) SWIG_fail;
40945 swig_obj[0] = args;
40946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40947 if (!SWIG_IsOK(res1)) {
40948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40949 }
40950 arg1 = reinterpret_cast< wxMenu * >(argp1);
40951 {
40952 PyThreadState* __tstate = wxPyBeginAllowThreads();
40953 result = (long)((wxMenu const *)arg1)->GetStyle();
40954 wxPyEndAllowThreads(__tstate);
40955 if (PyErr_Occurred()) SWIG_fail;
40956 }
40957 resultobj = SWIG_From_long(static_cast< long >(result));
40958 return resultobj;
40959 fail:
40960 return NULL;
40961 }
40962
40963
40964 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40965 PyObject *resultobj = 0;
40966 wxMenu *arg1 = (wxMenu *) 0 ;
40967 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40968 void *argp1 = 0 ;
40969 int res1 = 0 ;
40970 void *argp2 = 0 ;
40971 int res2 = 0 ;
40972 PyObject * obj0 = 0 ;
40973 PyObject * obj1 = 0 ;
40974 char * kwnames[] = {
40975 (char *) "self",(char *) "source", NULL
40976 };
40977
40978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40980 if (!SWIG_IsOK(res1)) {
40981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40982 }
40983 arg1 = reinterpret_cast< wxMenu * >(argp1);
40984 if (obj1) {
40985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40986 if (!SWIG_IsOK(res2)) {
40987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40988 }
40989 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40990 }
40991 {
40992 PyThreadState* __tstate = wxPyBeginAllowThreads();
40993 (arg1)->UpdateUI(arg2);
40994 wxPyEndAllowThreads(__tstate);
40995 if (PyErr_Occurred()) SWIG_fail;
40996 }
40997 resultobj = SWIG_Py_Void();
40998 return resultobj;
40999 fail:
41000 return NULL;
41001 }
41002
41003
41004 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41005 PyObject *resultobj = 0;
41006 wxMenu *arg1 = (wxMenu *) 0 ;
41007 wxMenuBar *result = 0 ;
41008 void *argp1 = 0 ;
41009 int res1 = 0 ;
41010 PyObject *swig_obj[1] ;
41011
41012 if (!args) SWIG_fail;
41013 swig_obj[0] = args;
41014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41015 if (!SWIG_IsOK(res1)) {
41016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41017 }
41018 arg1 = reinterpret_cast< wxMenu * >(argp1);
41019 {
41020 PyThreadState* __tstate = wxPyBeginAllowThreads();
41021 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41022 wxPyEndAllowThreads(__tstate);
41023 if (PyErr_Occurred()) SWIG_fail;
41024 }
41025 {
41026 resultobj = wxPyMake_wxObject(result, (bool)0);
41027 }
41028 return resultobj;
41029 fail:
41030 return NULL;
41031 }
41032
41033
41034 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41035 PyObject *resultobj = 0;
41036 wxMenu *arg1 = (wxMenu *) 0 ;
41037 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41038 void *argp1 = 0 ;
41039 int res1 = 0 ;
41040 void *argp2 = 0 ;
41041 int res2 = 0 ;
41042 PyObject * obj0 = 0 ;
41043 PyObject * obj1 = 0 ;
41044 char * kwnames[] = {
41045 (char *) "self",(char *) "menubar", NULL
41046 };
41047
41048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41050 if (!SWIG_IsOK(res1)) {
41051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41052 }
41053 arg1 = reinterpret_cast< wxMenu * >(argp1);
41054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41055 if (!SWIG_IsOK(res2)) {
41056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41057 }
41058 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41059 {
41060 PyThreadState* __tstate = wxPyBeginAllowThreads();
41061 (arg1)->Attach(arg2);
41062 wxPyEndAllowThreads(__tstate);
41063 if (PyErr_Occurred()) SWIG_fail;
41064 }
41065 resultobj = SWIG_Py_Void();
41066 return resultobj;
41067 fail:
41068 return NULL;
41069 }
41070
41071
41072 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41073 PyObject *resultobj = 0;
41074 wxMenu *arg1 = (wxMenu *) 0 ;
41075 void *argp1 = 0 ;
41076 int res1 = 0 ;
41077 PyObject *swig_obj[1] ;
41078
41079 if (!args) SWIG_fail;
41080 swig_obj[0] = args;
41081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41082 if (!SWIG_IsOK(res1)) {
41083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41084 }
41085 arg1 = reinterpret_cast< wxMenu * >(argp1);
41086 {
41087 PyThreadState* __tstate = wxPyBeginAllowThreads();
41088 (arg1)->Detach();
41089 wxPyEndAllowThreads(__tstate);
41090 if (PyErr_Occurred()) SWIG_fail;
41091 }
41092 resultobj = SWIG_Py_Void();
41093 return resultobj;
41094 fail:
41095 return NULL;
41096 }
41097
41098
41099 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41100 PyObject *resultobj = 0;
41101 wxMenu *arg1 = (wxMenu *) 0 ;
41102 bool result;
41103 void *argp1 = 0 ;
41104 int res1 = 0 ;
41105 PyObject *swig_obj[1] ;
41106
41107 if (!args) SWIG_fail;
41108 swig_obj[0] = args;
41109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41110 if (!SWIG_IsOK(res1)) {
41111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41112 }
41113 arg1 = reinterpret_cast< wxMenu * >(argp1);
41114 {
41115 PyThreadState* __tstate = wxPyBeginAllowThreads();
41116 result = (bool)((wxMenu const *)arg1)->IsAttached();
41117 wxPyEndAllowThreads(__tstate);
41118 if (PyErr_Occurred()) SWIG_fail;
41119 }
41120 {
41121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41122 }
41123 return resultobj;
41124 fail:
41125 return NULL;
41126 }
41127
41128
41129 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41130 PyObject *resultobj = 0;
41131 wxMenu *arg1 = (wxMenu *) 0 ;
41132 wxMenu *arg2 = (wxMenu *) 0 ;
41133 void *argp1 = 0 ;
41134 int res1 = 0 ;
41135 void *argp2 = 0 ;
41136 int res2 = 0 ;
41137 PyObject * obj0 = 0 ;
41138 PyObject * obj1 = 0 ;
41139 char * kwnames[] = {
41140 (char *) "self",(char *) "parent", NULL
41141 };
41142
41143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41145 if (!SWIG_IsOK(res1)) {
41146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41147 }
41148 arg1 = reinterpret_cast< wxMenu * >(argp1);
41149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41150 if (!SWIG_IsOK(res2)) {
41151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41152 }
41153 arg2 = reinterpret_cast< wxMenu * >(argp2);
41154 {
41155 PyThreadState* __tstate = wxPyBeginAllowThreads();
41156 (arg1)->SetParent(arg2);
41157 wxPyEndAllowThreads(__tstate);
41158 if (PyErr_Occurred()) SWIG_fail;
41159 }
41160 resultobj = SWIG_Py_Void();
41161 return resultobj;
41162 fail:
41163 return NULL;
41164 }
41165
41166
41167 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41168 PyObject *resultobj = 0;
41169 wxMenu *arg1 = (wxMenu *) 0 ;
41170 wxMenu *result = 0 ;
41171 void *argp1 = 0 ;
41172 int res1 = 0 ;
41173 PyObject *swig_obj[1] ;
41174
41175 if (!args) SWIG_fail;
41176 swig_obj[0] = args;
41177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41178 if (!SWIG_IsOK(res1)) {
41179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41180 }
41181 arg1 = reinterpret_cast< wxMenu * >(argp1);
41182 {
41183 PyThreadState* __tstate = wxPyBeginAllowThreads();
41184 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41185 wxPyEndAllowThreads(__tstate);
41186 if (PyErr_Occurred()) SWIG_fail;
41187 }
41188 {
41189 resultobj = wxPyMake_wxObject(result, 0);
41190 }
41191 return resultobj;
41192 fail:
41193 return NULL;
41194 }
41195
41196
41197 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41198 PyObject *obj;
41199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41200 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41201 return SWIG_Py_Void();
41202 }
41203
41204 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41205 return SWIG_Python_InitShadowInstance(args);
41206 }
41207
41208 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41209 PyObject *resultobj = 0;
41210 long arg1 = (long) 0 ;
41211 wxMenuBar *result = 0 ;
41212 long val1 ;
41213 int ecode1 = 0 ;
41214 PyObject * obj0 = 0 ;
41215 char * kwnames[] = {
41216 (char *) "style", NULL
41217 };
41218
41219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41220 if (obj0) {
41221 ecode1 = SWIG_AsVal_long(obj0, &val1);
41222 if (!SWIG_IsOK(ecode1)) {
41223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41224 }
41225 arg1 = static_cast< long >(val1);
41226 }
41227 {
41228 if (!wxPyCheckForApp()) SWIG_fail;
41229 PyThreadState* __tstate = wxPyBeginAllowThreads();
41230 result = (wxMenuBar *)new wxMenuBar(arg1);
41231 wxPyEndAllowThreads(__tstate);
41232 if (PyErr_Occurred()) SWIG_fail;
41233 }
41234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41235 return resultobj;
41236 fail:
41237 return NULL;
41238 }
41239
41240
41241 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41242 PyObject *resultobj = 0;
41243 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41244 wxMenu *arg2 = (wxMenu *) 0 ;
41245 wxString *arg3 = 0 ;
41246 bool result;
41247 void *argp1 = 0 ;
41248 int res1 = 0 ;
41249 void *argp2 = 0 ;
41250 int res2 = 0 ;
41251 bool temp3 = false ;
41252 PyObject * obj0 = 0 ;
41253 PyObject * obj1 = 0 ;
41254 PyObject * obj2 = 0 ;
41255 char * kwnames[] = {
41256 (char *) "self",(char *) "menu",(char *) "title", NULL
41257 };
41258
41259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41261 if (!SWIG_IsOK(res1)) {
41262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41263 }
41264 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41265 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41266 if (!SWIG_IsOK(res2)) {
41267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41268 }
41269 arg2 = reinterpret_cast< wxMenu * >(argp2);
41270 {
41271 arg3 = wxString_in_helper(obj2);
41272 if (arg3 == NULL) SWIG_fail;
41273 temp3 = true;
41274 }
41275 {
41276 PyThreadState* __tstate = wxPyBeginAllowThreads();
41277 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41278 wxPyEndAllowThreads(__tstate);
41279 if (PyErr_Occurred()) SWIG_fail;
41280 }
41281 {
41282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41283 }
41284 {
41285 if (temp3)
41286 delete arg3;
41287 }
41288 return resultobj;
41289 fail:
41290 {
41291 if (temp3)
41292 delete arg3;
41293 }
41294 return NULL;
41295 }
41296
41297
41298 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41299 PyObject *resultobj = 0;
41300 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41301 size_t arg2 ;
41302 wxMenu *arg3 = (wxMenu *) 0 ;
41303 wxString *arg4 = 0 ;
41304 bool result;
41305 void *argp1 = 0 ;
41306 int res1 = 0 ;
41307 size_t val2 ;
41308 int ecode2 = 0 ;
41309 void *argp3 = 0 ;
41310 int res3 = 0 ;
41311 bool temp4 = false ;
41312 PyObject * obj0 = 0 ;
41313 PyObject * obj1 = 0 ;
41314 PyObject * obj2 = 0 ;
41315 PyObject * obj3 = 0 ;
41316 char * kwnames[] = {
41317 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41318 };
41319
41320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41322 if (!SWIG_IsOK(res1)) {
41323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41324 }
41325 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41326 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41327 if (!SWIG_IsOK(ecode2)) {
41328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41329 }
41330 arg2 = static_cast< size_t >(val2);
41331 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41332 if (!SWIG_IsOK(res3)) {
41333 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41334 }
41335 arg3 = reinterpret_cast< wxMenu * >(argp3);
41336 {
41337 arg4 = wxString_in_helper(obj3);
41338 if (arg4 == NULL) SWIG_fail;
41339 temp4 = true;
41340 }
41341 {
41342 PyThreadState* __tstate = wxPyBeginAllowThreads();
41343 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41344 wxPyEndAllowThreads(__tstate);
41345 if (PyErr_Occurred()) SWIG_fail;
41346 }
41347 {
41348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41349 }
41350 {
41351 if (temp4)
41352 delete arg4;
41353 }
41354 return resultobj;
41355 fail:
41356 {
41357 if (temp4)
41358 delete arg4;
41359 }
41360 return NULL;
41361 }
41362
41363
41364 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41365 PyObject *resultobj = 0;
41366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41367 size_t result;
41368 void *argp1 = 0 ;
41369 int res1 = 0 ;
41370 PyObject *swig_obj[1] ;
41371
41372 if (!args) SWIG_fail;
41373 swig_obj[0] = args;
41374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41375 if (!SWIG_IsOK(res1)) {
41376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41377 }
41378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41379 {
41380 PyThreadState* __tstate = wxPyBeginAllowThreads();
41381 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41382 wxPyEndAllowThreads(__tstate);
41383 if (PyErr_Occurred()) SWIG_fail;
41384 }
41385 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41386 return resultobj;
41387 fail:
41388 return NULL;
41389 }
41390
41391
41392 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj = 0;
41394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41395 size_t arg2 ;
41396 wxMenu *result = 0 ;
41397 void *argp1 = 0 ;
41398 int res1 = 0 ;
41399 size_t val2 ;
41400 int ecode2 = 0 ;
41401 PyObject * obj0 = 0 ;
41402 PyObject * obj1 = 0 ;
41403 char * kwnames[] = {
41404 (char *) "self",(char *) "pos", NULL
41405 };
41406
41407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41409 if (!SWIG_IsOK(res1)) {
41410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41411 }
41412 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41413 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41414 if (!SWIG_IsOK(ecode2)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41416 }
41417 arg2 = static_cast< size_t >(val2);
41418 {
41419 PyThreadState* __tstate = wxPyBeginAllowThreads();
41420 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 {
41425 resultobj = wxPyMake_wxObject(result, 0);
41426 }
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41434 PyObject *resultobj = 0;
41435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41436 size_t arg2 ;
41437 wxMenu *arg3 = (wxMenu *) 0 ;
41438 wxString *arg4 = 0 ;
41439 wxMenu *result = 0 ;
41440 void *argp1 = 0 ;
41441 int res1 = 0 ;
41442 size_t val2 ;
41443 int ecode2 = 0 ;
41444 void *argp3 = 0 ;
41445 int res3 = 0 ;
41446 bool temp4 = false ;
41447 PyObject * obj0 = 0 ;
41448 PyObject * obj1 = 0 ;
41449 PyObject * obj2 = 0 ;
41450 PyObject * obj3 = 0 ;
41451 char * kwnames[] = {
41452 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41453 };
41454
41455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41457 if (!SWIG_IsOK(res1)) {
41458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41459 }
41460 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41461 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41462 if (!SWIG_IsOK(ecode2)) {
41463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41464 }
41465 arg2 = static_cast< size_t >(val2);
41466 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41467 if (!SWIG_IsOK(res3)) {
41468 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41469 }
41470 arg3 = reinterpret_cast< wxMenu * >(argp3);
41471 {
41472 arg4 = wxString_in_helper(obj3);
41473 if (arg4 == NULL) SWIG_fail;
41474 temp4 = true;
41475 }
41476 {
41477 PyThreadState* __tstate = wxPyBeginAllowThreads();
41478 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41479 wxPyEndAllowThreads(__tstate);
41480 if (PyErr_Occurred()) SWIG_fail;
41481 }
41482 {
41483 resultobj = wxPyMake_wxObject(result, 0);
41484 }
41485 {
41486 if (temp4)
41487 delete arg4;
41488 }
41489 return resultobj;
41490 fail:
41491 {
41492 if (temp4)
41493 delete arg4;
41494 }
41495 return NULL;
41496 }
41497
41498
41499 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41500 PyObject *resultobj = 0;
41501 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41502 size_t arg2 ;
41503 wxMenu *result = 0 ;
41504 void *argp1 = 0 ;
41505 int res1 = 0 ;
41506 size_t val2 ;
41507 int ecode2 = 0 ;
41508 PyObject * obj0 = 0 ;
41509 PyObject * obj1 = 0 ;
41510 char * kwnames[] = {
41511 (char *) "self",(char *) "pos", NULL
41512 };
41513
41514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41516 if (!SWIG_IsOK(res1)) {
41517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41518 }
41519 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41520 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41521 if (!SWIG_IsOK(ecode2)) {
41522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41523 }
41524 arg2 = static_cast< size_t >(val2);
41525 {
41526 PyThreadState* __tstate = wxPyBeginAllowThreads();
41527 result = (wxMenu *)(arg1)->Remove(arg2);
41528 wxPyEndAllowThreads(__tstate);
41529 if (PyErr_Occurred()) SWIG_fail;
41530 }
41531 {
41532 resultobj = wxPyMake_wxObject(result, 0);
41533 }
41534 return resultobj;
41535 fail:
41536 return NULL;
41537 }
41538
41539
41540 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41541 PyObject *resultobj = 0;
41542 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41543 size_t arg2 ;
41544 bool arg3 ;
41545 void *argp1 = 0 ;
41546 int res1 = 0 ;
41547 size_t val2 ;
41548 int ecode2 = 0 ;
41549 bool val3 ;
41550 int ecode3 = 0 ;
41551 PyObject * obj0 = 0 ;
41552 PyObject * obj1 = 0 ;
41553 PyObject * obj2 = 0 ;
41554 char * kwnames[] = {
41555 (char *) "self",(char *) "pos",(char *) "enable", NULL
41556 };
41557
41558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41560 if (!SWIG_IsOK(res1)) {
41561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41562 }
41563 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41564 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41565 if (!SWIG_IsOK(ecode2)) {
41566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41567 }
41568 arg2 = static_cast< size_t >(val2);
41569 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41570 if (!SWIG_IsOK(ecode3)) {
41571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41572 }
41573 arg3 = static_cast< bool >(val3);
41574 {
41575 PyThreadState* __tstate = wxPyBeginAllowThreads();
41576 (arg1)->EnableTop(arg2,arg3);
41577 wxPyEndAllowThreads(__tstate);
41578 if (PyErr_Occurred()) SWIG_fail;
41579 }
41580 resultobj = SWIG_Py_Void();
41581 return resultobj;
41582 fail:
41583 return NULL;
41584 }
41585
41586
41587 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41588 PyObject *resultobj = 0;
41589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41590 size_t arg2 ;
41591 bool result;
41592 void *argp1 = 0 ;
41593 int res1 = 0 ;
41594 size_t val2 ;
41595 int ecode2 = 0 ;
41596 PyObject * obj0 = 0 ;
41597 PyObject * obj1 = 0 ;
41598 char * kwnames[] = {
41599 (char *) "self",(char *) "pos", NULL
41600 };
41601
41602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41604 if (!SWIG_IsOK(res1)) {
41605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41606 }
41607 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41608 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41609 if (!SWIG_IsOK(ecode2)) {
41610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41611 }
41612 arg2 = static_cast< size_t >(val2);
41613 {
41614 PyThreadState* __tstate = wxPyBeginAllowThreads();
41615 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41616 wxPyEndAllowThreads(__tstate);
41617 if (PyErr_Occurred()) SWIG_fail;
41618 }
41619 {
41620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41621 }
41622 return resultobj;
41623 fail:
41624 return NULL;
41625 }
41626
41627
41628 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41629 PyObject *resultobj = 0;
41630 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41631 size_t arg2 ;
41632 wxString *arg3 = 0 ;
41633 void *argp1 = 0 ;
41634 int res1 = 0 ;
41635 size_t val2 ;
41636 int ecode2 = 0 ;
41637 bool temp3 = false ;
41638 PyObject * obj0 = 0 ;
41639 PyObject * obj1 = 0 ;
41640 PyObject * obj2 = 0 ;
41641 char * kwnames[] = {
41642 (char *) "self",(char *) "pos",(char *) "label", NULL
41643 };
41644
41645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41647 if (!SWIG_IsOK(res1)) {
41648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41649 }
41650 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41651 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41652 if (!SWIG_IsOK(ecode2)) {
41653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41654 }
41655 arg2 = static_cast< size_t >(val2);
41656 {
41657 arg3 = wxString_in_helper(obj2);
41658 if (arg3 == NULL) SWIG_fail;
41659 temp3 = true;
41660 }
41661 {
41662 PyThreadState* __tstate = wxPyBeginAllowThreads();
41663 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41664 wxPyEndAllowThreads(__tstate);
41665 if (PyErr_Occurred()) SWIG_fail;
41666 }
41667 resultobj = SWIG_Py_Void();
41668 {
41669 if (temp3)
41670 delete arg3;
41671 }
41672 return resultobj;
41673 fail:
41674 {
41675 if (temp3)
41676 delete arg3;
41677 }
41678 return NULL;
41679 }
41680
41681
41682 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41683 PyObject *resultobj = 0;
41684 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41685 size_t arg2 ;
41686 wxString result;
41687 void *argp1 = 0 ;
41688 int res1 = 0 ;
41689 size_t val2 ;
41690 int ecode2 = 0 ;
41691 PyObject * obj0 = 0 ;
41692 PyObject * obj1 = 0 ;
41693 char * kwnames[] = {
41694 (char *) "self",(char *) "pos", NULL
41695 };
41696
41697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41699 if (!SWIG_IsOK(res1)) {
41700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41701 }
41702 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41703 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41704 if (!SWIG_IsOK(ecode2)) {
41705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41706 }
41707 arg2 = static_cast< size_t >(val2);
41708 {
41709 PyThreadState* __tstate = wxPyBeginAllowThreads();
41710 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41711 wxPyEndAllowThreads(__tstate);
41712 if (PyErr_Occurred()) SWIG_fail;
41713 }
41714 {
41715 #if wxUSE_UNICODE
41716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41717 #else
41718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41719 #endif
41720 }
41721 return resultobj;
41722 fail:
41723 return NULL;
41724 }
41725
41726
41727 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41728 PyObject *resultobj = 0;
41729 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41730 wxString *arg2 = 0 ;
41731 wxString *arg3 = 0 ;
41732 int result;
41733 void *argp1 = 0 ;
41734 int res1 = 0 ;
41735 bool temp2 = false ;
41736 bool temp3 = false ;
41737 PyObject * obj0 = 0 ;
41738 PyObject * obj1 = 0 ;
41739 PyObject * obj2 = 0 ;
41740 char * kwnames[] = {
41741 (char *) "self",(char *) "menu",(char *) "item", NULL
41742 };
41743
41744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41746 if (!SWIG_IsOK(res1)) {
41747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41748 }
41749 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41750 {
41751 arg2 = wxString_in_helper(obj1);
41752 if (arg2 == NULL) SWIG_fail;
41753 temp2 = true;
41754 }
41755 {
41756 arg3 = wxString_in_helper(obj2);
41757 if (arg3 == NULL) SWIG_fail;
41758 temp3 = true;
41759 }
41760 {
41761 PyThreadState* __tstate = wxPyBeginAllowThreads();
41762 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41763 wxPyEndAllowThreads(__tstate);
41764 if (PyErr_Occurred()) SWIG_fail;
41765 }
41766 resultobj = SWIG_From_int(static_cast< int >(result));
41767 {
41768 if (temp2)
41769 delete arg2;
41770 }
41771 {
41772 if (temp3)
41773 delete arg3;
41774 }
41775 return resultobj;
41776 fail:
41777 {
41778 if (temp2)
41779 delete arg2;
41780 }
41781 {
41782 if (temp3)
41783 delete arg3;
41784 }
41785 return NULL;
41786 }
41787
41788
41789 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41790 PyObject *resultobj = 0;
41791 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41792 int arg2 ;
41793 wxMenuItem *result = 0 ;
41794 void *argp1 = 0 ;
41795 int res1 = 0 ;
41796 int val2 ;
41797 int ecode2 = 0 ;
41798 PyObject * obj0 = 0 ;
41799 PyObject * obj1 = 0 ;
41800 char * kwnames[] = {
41801 (char *) "self",(char *) "id", NULL
41802 };
41803
41804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41806 if (!SWIG_IsOK(res1)) {
41807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41808 }
41809 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41810 ecode2 = SWIG_AsVal_int(obj1, &val2);
41811 if (!SWIG_IsOK(ecode2)) {
41812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41813 }
41814 arg2 = static_cast< int >(val2);
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41818 wxPyEndAllowThreads(__tstate);
41819 if (PyErr_Occurred()) SWIG_fail;
41820 }
41821 {
41822 resultobj = wxPyMake_wxObject(result, (bool)0);
41823 }
41824 return resultobj;
41825 fail:
41826 return NULL;
41827 }
41828
41829
41830 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41831 PyObject *resultobj = 0;
41832 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41833 wxString *arg2 = 0 ;
41834 int result;
41835 void *argp1 = 0 ;
41836 int res1 = 0 ;
41837 bool temp2 = false ;
41838 PyObject * obj0 = 0 ;
41839 PyObject * obj1 = 0 ;
41840 char * kwnames[] = {
41841 (char *) "self",(char *) "title", NULL
41842 };
41843
41844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41846 if (!SWIG_IsOK(res1)) {
41847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41848 }
41849 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41850 {
41851 arg2 = wxString_in_helper(obj1);
41852 if (arg2 == NULL) SWIG_fail;
41853 temp2 = true;
41854 }
41855 {
41856 PyThreadState* __tstate = wxPyBeginAllowThreads();
41857 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41858 wxPyEndAllowThreads(__tstate);
41859 if (PyErr_Occurred()) SWIG_fail;
41860 }
41861 resultobj = SWIG_From_int(static_cast< int >(result));
41862 {
41863 if (temp2)
41864 delete arg2;
41865 }
41866 return resultobj;
41867 fail:
41868 {
41869 if (temp2)
41870 delete arg2;
41871 }
41872 return NULL;
41873 }
41874
41875
41876 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41877 PyObject *resultobj = 0;
41878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41879 int arg2 ;
41880 bool arg3 ;
41881 void *argp1 = 0 ;
41882 int res1 = 0 ;
41883 int val2 ;
41884 int ecode2 = 0 ;
41885 bool val3 ;
41886 int ecode3 = 0 ;
41887 PyObject * obj0 = 0 ;
41888 PyObject * obj1 = 0 ;
41889 PyObject * obj2 = 0 ;
41890 char * kwnames[] = {
41891 (char *) "self",(char *) "id",(char *) "enable", NULL
41892 };
41893
41894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41896 if (!SWIG_IsOK(res1)) {
41897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41898 }
41899 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41900 ecode2 = SWIG_AsVal_int(obj1, &val2);
41901 if (!SWIG_IsOK(ecode2)) {
41902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41903 }
41904 arg2 = static_cast< int >(val2);
41905 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41906 if (!SWIG_IsOK(ecode3)) {
41907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41908 }
41909 arg3 = static_cast< bool >(val3);
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 (arg1)->Enable(arg2,arg3);
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 resultobj = SWIG_Py_Void();
41917 return resultobj;
41918 fail:
41919 return NULL;
41920 }
41921
41922
41923 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41924 PyObject *resultobj = 0;
41925 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41926 int arg2 ;
41927 bool arg3 ;
41928 void *argp1 = 0 ;
41929 int res1 = 0 ;
41930 int val2 ;
41931 int ecode2 = 0 ;
41932 bool val3 ;
41933 int ecode3 = 0 ;
41934 PyObject * obj0 = 0 ;
41935 PyObject * obj1 = 0 ;
41936 PyObject * obj2 = 0 ;
41937 char * kwnames[] = {
41938 (char *) "self",(char *) "id",(char *) "check", NULL
41939 };
41940
41941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41943 if (!SWIG_IsOK(res1)) {
41944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41945 }
41946 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41947 ecode2 = SWIG_AsVal_int(obj1, &val2);
41948 if (!SWIG_IsOK(ecode2)) {
41949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41950 }
41951 arg2 = static_cast< int >(val2);
41952 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41953 if (!SWIG_IsOK(ecode3)) {
41954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41955 }
41956 arg3 = static_cast< bool >(val3);
41957 {
41958 PyThreadState* __tstate = wxPyBeginAllowThreads();
41959 (arg1)->Check(arg2,arg3);
41960 wxPyEndAllowThreads(__tstate);
41961 if (PyErr_Occurred()) SWIG_fail;
41962 }
41963 resultobj = SWIG_Py_Void();
41964 return resultobj;
41965 fail:
41966 return NULL;
41967 }
41968
41969
41970 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41971 PyObject *resultobj = 0;
41972 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41973 int arg2 ;
41974 bool result;
41975 void *argp1 = 0 ;
41976 int res1 = 0 ;
41977 int val2 ;
41978 int ecode2 = 0 ;
41979 PyObject * obj0 = 0 ;
41980 PyObject * obj1 = 0 ;
41981 char * kwnames[] = {
41982 (char *) "self",(char *) "id", NULL
41983 };
41984
41985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41987 if (!SWIG_IsOK(res1)) {
41988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41989 }
41990 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41991 ecode2 = SWIG_AsVal_int(obj1, &val2);
41992 if (!SWIG_IsOK(ecode2)) {
41993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41994 }
41995 arg2 = static_cast< int >(val2);
41996 {
41997 PyThreadState* __tstate = wxPyBeginAllowThreads();
41998 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41999 wxPyEndAllowThreads(__tstate);
42000 if (PyErr_Occurred()) SWIG_fail;
42001 }
42002 {
42003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42004 }
42005 return resultobj;
42006 fail:
42007 return NULL;
42008 }
42009
42010
42011 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42012 PyObject *resultobj = 0;
42013 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42014 int arg2 ;
42015 bool result;
42016 void *argp1 = 0 ;
42017 int res1 = 0 ;
42018 int val2 ;
42019 int ecode2 = 0 ;
42020 PyObject * obj0 = 0 ;
42021 PyObject * obj1 = 0 ;
42022 char * kwnames[] = {
42023 (char *) "self",(char *) "id", NULL
42024 };
42025
42026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42028 if (!SWIG_IsOK(res1)) {
42029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42030 }
42031 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42032 ecode2 = SWIG_AsVal_int(obj1, &val2);
42033 if (!SWIG_IsOK(ecode2)) {
42034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42035 }
42036 arg2 = static_cast< int >(val2);
42037 {
42038 PyThreadState* __tstate = wxPyBeginAllowThreads();
42039 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42040 wxPyEndAllowThreads(__tstate);
42041 if (PyErr_Occurred()) SWIG_fail;
42042 }
42043 {
42044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42045 }
42046 return resultobj;
42047 fail:
42048 return NULL;
42049 }
42050
42051
42052 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42053 PyObject *resultobj = 0;
42054 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42055 int arg2 ;
42056 wxString *arg3 = 0 ;
42057 void *argp1 = 0 ;
42058 int res1 = 0 ;
42059 int val2 ;
42060 int ecode2 = 0 ;
42061 bool temp3 = false ;
42062 PyObject * obj0 = 0 ;
42063 PyObject * obj1 = 0 ;
42064 PyObject * obj2 = 0 ;
42065 char * kwnames[] = {
42066 (char *) "self",(char *) "id",(char *) "label", NULL
42067 };
42068
42069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42071 if (!SWIG_IsOK(res1)) {
42072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42073 }
42074 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42075 ecode2 = SWIG_AsVal_int(obj1, &val2);
42076 if (!SWIG_IsOK(ecode2)) {
42077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42078 }
42079 arg2 = static_cast< int >(val2);
42080 {
42081 arg3 = wxString_in_helper(obj2);
42082 if (arg3 == NULL) SWIG_fail;
42083 temp3 = true;
42084 }
42085 {
42086 PyThreadState* __tstate = wxPyBeginAllowThreads();
42087 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42088 wxPyEndAllowThreads(__tstate);
42089 if (PyErr_Occurred()) SWIG_fail;
42090 }
42091 resultobj = SWIG_Py_Void();
42092 {
42093 if (temp3)
42094 delete arg3;
42095 }
42096 return resultobj;
42097 fail:
42098 {
42099 if (temp3)
42100 delete arg3;
42101 }
42102 return NULL;
42103 }
42104
42105
42106 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42107 PyObject *resultobj = 0;
42108 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42109 int arg2 ;
42110 wxString result;
42111 void *argp1 = 0 ;
42112 int res1 = 0 ;
42113 int val2 ;
42114 int ecode2 = 0 ;
42115 PyObject * obj0 = 0 ;
42116 PyObject * obj1 = 0 ;
42117 char * kwnames[] = {
42118 (char *) "self",(char *) "id", NULL
42119 };
42120
42121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42123 if (!SWIG_IsOK(res1)) {
42124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42125 }
42126 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42127 ecode2 = SWIG_AsVal_int(obj1, &val2);
42128 if (!SWIG_IsOK(ecode2)) {
42129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42130 }
42131 arg2 = static_cast< int >(val2);
42132 {
42133 PyThreadState* __tstate = wxPyBeginAllowThreads();
42134 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42135 wxPyEndAllowThreads(__tstate);
42136 if (PyErr_Occurred()) SWIG_fail;
42137 }
42138 {
42139 #if wxUSE_UNICODE
42140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42141 #else
42142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42143 #endif
42144 }
42145 return resultobj;
42146 fail:
42147 return NULL;
42148 }
42149
42150
42151 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42152 PyObject *resultobj = 0;
42153 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42154 int arg2 ;
42155 wxString *arg3 = 0 ;
42156 void *argp1 = 0 ;
42157 int res1 = 0 ;
42158 int val2 ;
42159 int ecode2 = 0 ;
42160 bool temp3 = false ;
42161 PyObject * obj0 = 0 ;
42162 PyObject * obj1 = 0 ;
42163 PyObject * obj2 = 0 ;
42164 char * kwnames[] = {
42165 (char *) "self",(char *) "id",(char *) "helpString", NULL
42166 };
42167
42168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42170 if (!SWIG_IsOK(res1)) {
42171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42172 }
42173 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42174 ecode2 = SWIG_AsVal_int(obj1, &val2);
42175 if (!SWIG_IsOK(ecode2)) {
42176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42177 }
42178 arg2 = static_cast< int >(val2);
42179 {
42180 arg3 = wxString_in_helper(obj2);
42181 if (arg3 == NULL) SWIG_fail;
42182 temp3 = true;
42183 }
42184 {
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 resultobj = SWIG_Py_Void();
42191 {
42192 if (temp3)
42193 delete arg3;
42194 }
42195 return resultobj;
42196 fail:
42197 {
42198 if (temp3)
42199 delete arg3;
42200 }
42201 return NULL;
42202 }
42203
42204
42205 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42206 PyObject *resultobj = 0;
42207 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42208 int arg2 ;
42209 wxString result;
42210 void *argp1 = 0 ;
42211 int res1 = 0 ;
42212 int val2 ;
42213 int ecode2 = 0 ;
42214 PyObject * obj0 = 0 ;
42215 PyObject * obj1 = 0 ;
42216 char * kwnames[] = {
42217 (char *) "self",(char *) "id", NULL
42218 };
42219
42220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42222 if (!SWIG_IsOK(res1)) {
42223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42224 }
42225 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42226 ecode2 = SWIG_AsVal_int(obj1, &val2);
42227 if (!SWIG_IsOK(ecode2)) {
42228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42229 }
42230 arg2 = static_cast< int >(val2);
42231 {
42232 PyThreadState* __tstate = wxPyBeginAllowThreads();
42233 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 {
42238 #if wxUSE_UNICODE
42239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42240 #else
42241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42242 #endif
42243 }
42244 return resultobj;
42245 fail:
42246 return NULL;
42247 }
42248
42249
42250 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42251 PyObject *resultobj = 0;
42252 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42253 wxFrame *result = 0 ;
42254 void *argp1 = 0 ;
42255 int res1 = 0 ;
42256 PyObject *swig_obj[1] ;
42257
42258 if (!args) SWIG_fail;
42259 swig_obj[0] = args;
42260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42261 if (!SWIG_IsOK(res1)) {
42262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42263 }
42264 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42265 {
42266 PyThreadState* __tstate = wxPyBeginAllowThreads();
42267 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42268 wxPyEndAllowThreads(__tstate);
42269 if (PyErr_Occurred()) SWIG_fail;
42270 }
42271 {
42272 resultobj = wxPyMake_wxObject(result, (bool)0);
42273 }
42274 return resultobj;
42275 fail:
42276 return NULL;
42277 }
42278
42279
42280 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42281 PyObject *resultobj = 0;
42282 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42283 bool result;
42284 void *argp1 = 0 ;
42285 int res1 = 0 ;
42286 PyObject *swig_obj[1] ;
42287
42288 if (!args) SWIG_fail;
42289 swig_obj[0] = args;
42290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42291 if (!SWIG_IsOK(res1)) {
42292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42293 }
42294 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42295 {
42296 PyThreadState* __tstate = wxPyBeginAllowThreads();
42297 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42298 wxPyEndAllowThreads(__tstate);
42299 if (PyErr_Occurred()) SWIG_fail;
42300 }
42301 {
42302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42303 }
42304 return resultobj;
42305 fail:
42306 return NULL;
42307 }
42308
42309
42310 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42311 PyObject *resultobj = 0;
42312 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42313 wxFrame *arg2 = (wxFrame *) 0 ;
42314 void *argp1 = 0 ;
42315 int res1 = 0 ;
42316 void *argp2 = 0 ;
42317 int res2 = 0 ;
42318 PyObject * obj0 = 0 ;
42319 PyObject * obj1 = 0 ;
42320 char * kwnames[] = {
42321 (char *) "self",(char *) "frame", NULL
42322 };
42323
42324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42326 if (!SWIG_IsOK(res1)) {
42327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42328 }
42329 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42331 if (!SWIG_IsOK(res2)) {
42332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42333 }
42334 arg2 = reinterpret_cast< wxFrame * >(argp2);
42335 {
42336 PyThreadState* __tstate = wxPyBeginAllowThreads();
42337 (arg1)->Attach(arg2);
42338 wxPyEndAllowThreads(__tstate);
42339 if (PyErr_Occurred()) SWIG_fail;
42340 }
42341 resultobj = SWIG_Py_Void();
42342 return resultobj;
42343 fail:
42344 return NULL;
42345 }
42346
42347
42348 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42349 PyObject *resultobj = 0;
42350 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42351 void *argp1 = 0 ;
42352 int res1 = 0 ;
42353 PyObject *swig_obj[1] ;
42354
42355 if (!args) SWIG_fail;
42356 swig_obj[0] = args;
42357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42358 if (!SWIG_IsOK(res1)) {
42359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42360 }
42361 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42362 {
42363 PyThreadState* __tstate = wxPyBeginAllowThreads();
42364 (arg1)->Detach();
42365 wxPyEndAllowThreads(__tstate);
42366 if (PyErr_Occurred()) SWIG_fail;
42367 }
42368 resultobj = SWIG_Py_Void();
42369 return resultobj;
42370 fail:
42371 return NULL;
42372 }
42373
42374
42375 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42376 PyObject *resultobj = 0;
42377 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42378 void *argp1 = 0 ;
42379 int res1 = 0 ;
42380 PyObject *swig_obj[1] ;
42381
42382 if (!args) SWIG_fail;
42383 swig_obj[0] = args;
42384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42385 if (!SWIG_IsOK(res1)) {
42386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42387 }
42388 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42389 {
42390 PyThreadState* __tstate = wxPyBeginAllowThreads();
42391 (arg1)->UpdateMenus();
42392 wxPyEndAllowThreads(__tstate);
42393 if (PyErr_Occurred()) SWIG_fail;
42394 }
42395 resultobj = SWIG_Py_Void();
42396 return resultobj;
42397 fail:
42398 return NULL;
42399 }
42400
42401
42402 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42403 PyObject *resultobj = 0;
42404 bool arg1 ;
42405 bool val1 ;
42406 int ecode1 = 0 ;
42407 PyObject * obj0 = 0 ;
42408 char * kwnames[] = {
42409 (char *) "enable", NULL
42410 };
42411
42412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42413 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42414 if (!SWIG_IsOK(ecode1)) {
42415 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42416 }
42417 arg1 = static_cast< bool >(val1);
42418 {
42419 PyThreadState* __tstate = wxPyBeginAllowThreads();
42420 wxMenuBar_SetAutoWindowMenu(arg1);
42421 wxPyEndAllowThreads(__tstate);
42422 if (PyErr_Occurred()) SWIG_fail;
42423 }
42424 resultobj = SWIG_Py_Void();
42425 return resultobj;
42426 fail:
42427 return NULL;
42428 }
42429
42430
42431 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42432 PyObject *resultobj = 0;
42433 bool result;
42434
42435 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42436 {
42437 PyThreadState* __tstate = wxPyBeginAllowThreads();
42438 result = (bool)wxMenuBar_GetAutoWindowMenu();
42439 wxPyEndAllowThreads(__tstate);
42440 if (PyErr_Occurred()) SWIG_fail;
42441 }
42442 {
42443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42444 }
42445 return resultobj;
42446 fail:
42447 return NULL;
42448 }
42449
42450
42451 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42452 PyObject *obj;
42453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42454 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42455 return SWIG_Py_Void();
42456 }
42457
42458 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42459 return SWIG_Python_InitShadowInstance(args);
42460 }
42461
42462 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42463 PyObject *resultobj = 0;
42464 wxMenu *arg1 = (wxMenu *) NULL ;
42465 int arg2 = (int) wxID_ANY ;
42466 wxString const &arg3_defvalue = wxPyEmptyString ;
42467 wxString *arg3 = (wxString *) &arg3_defvalue ;
42468 wxString const &arg4_defvalue = wxPyEmptyString ;
42469 wxString *arg4 = (wxString *) &arg4_defvalue ;
42470 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42471 wxMenu *arg6 = (wxMenu *) NULL ;
42472 wxMenuItem *result = 0 ;
42473 void *argp1 = 0 ;
42474 int res1 = 0 ;
42475 int val2 ;
42476 int ecode2 = 0 ;
42477 bool temp3 = false ;
42478 bool temp4 = false ;
42479 int val5 ;
42480 int ecode5 = 0 ;
42481 void *argp6 = 0 ;
42482 int res6 = 0 ;
42483 PyObject * obj0 = 0 ;
42484 PyObject * obj1 = 0 ;
42485 PyObject * obj2 = 0 ;
42486 PyObject * obj3 = 0 ;
42487 PyObject * obj4 = 0 ;
42488 PyObject * obj5 = 0 ;
42489 char * kwnames[] = {
42490 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42491 };
42492
42493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42494 if (obj0) {
42495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42496 if (!SWIG_IsOK(res1)) {
42497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42498 }
42499 arg1 = reinterpret_cast< wxMenu * >(argp1);
42500 }
42501 if (obj1) {
42502 ecode2 = SWIG_AsVal_int(obj1, &val2);
42503 if (!SWIG_IsOK(ecode2)) {
42504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42505 }
42506 arg2 = static_cast< int >(val2);
42507 }
42508 if (obj2) {
42509 {
42510 arg3 = wxString_in_helper(obj2);
42511 if (arg3 == NULL) SWIG_fail;
42512 temp3 = true;
42513 }
42514 }
42515 if (obj3) {
42516 {
42517 arg4 = wxString_in_helper(obj3);
42518 if (arg4 == NULL) SWIG_fail;
42519 temp4 = true;
42520 }
42521 }
42522 if (obj4) {
42523 ecode5 = SWIG_AsVal_int(obj4, &val5);
42524 if (!SWIG_IsOK(ecode5)) {
42525 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42526 }
42527 arg5 = static_cast< wxItemKind >(val5);
42528 }
42529 if (obj5) {
42530 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42531 if (!SWIG_IsOK(res6)) {
42532 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42533 }
42534 arg6 = reinterpret_cast< wxMenu * >(argp6);
42535 }
42536 {
42537 PyThreadState* __tstate = wxPyBeginAllowThreads();
42538 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42539 wxPyEndAllowThreads(__tstate);
42540 if (PyErr_Occurred()) SWIG_fail;
42541 }
42542 {
42543 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42544 }
42545 {
42546 if (temp3)
42547 delete arg3;
42548 }
42549 {
42550 if (temp4)
42551 delete arg4;
42552 }
42553 return resultobj;
42554 fail:
42555 {
42556 if (temp3)
42557 delete arg3;
42558 }
42559 {
42560 if (temp4)
42561 delete arg4;
42562 }
42563 return NULL;
42564 }
42565
42566
42567 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42568 PyObject *resultobj = 0;
42569 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42570 void *argp1 = 0 ;
42571 int res1 = 0 ;
42572 PyObject *swig_obj[1] ;
42573
42574 if (!args) SWIG_fail;
42575 swig_obj[0] = args;
42576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42577 if (!SWIG_IsOK(res1)) {
42578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42579 }
42580 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42581 {
42582 PyThreadState* __tstate = wxPyBeginAllowThreads();
42583 delete arg1;
42584
42585 wxPyEndAllowThreads(__tstate);
42586 if (PyErr_Occurred()) SWIG_fail;
42587 }
42588 resultobj = SWIG_Py_Void();
42589 return resultobj;
42590 fail:
42591 return NULL;
42592 }
42593
42594
42595 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42596 PyObject *resultobj = 0;
42597 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42598 wxMenu *result = 0 ;
42599 void *argp1 = 0 ;
42600 int res1 = 0 ;
42601 PyObject *swig_obj[1] ;
42602
42603 if (!args) SWIG_fail;
42604 swig_obj[0] = args;
42605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42606 if (!SWIG_IsOK(res1)) {
42607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42608 }
42609 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42610 {
42611 PyThreadState* __tstate = wxPyBeginAllowThreads();
42612 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42613 wxPyEndAllowThreads(__tstate);
42614 if (PyErr_Occurred()) SWIG_fail;
42615 }
42616 {
42617 resultobj = wxPyMake_wxObject(result, 0);
42618 }
42619 return resultobj;
42620 fail:
42621 return NULL;
42622 }
42623
42624
42625 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42626 PyObject *resultobj = 0;
42627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42628 wxMenu *arg2 = (wxMenu *) 0 ;
42629 void *argp1 = 0 ;
42630 int res1 = 0 ;
42631 void *argp2 = 0 ;
42632 int res2 = 0 ;
42633 PyObject * obj0 = 0 ;
42634 PyObject * obj1 = 0 ;
42635 char * kwnames[] = {
42636 (char *) "self",(char *) "menu", NULL
42637 };
42638
42639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42641 if (!SWIG_IsOK(res1)) {
42642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42643 }
42644 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42646 if (!SWIG_IsOK(res2)) {
42647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42648 }
42649 arg2 = reinterpret_cast< wxMenu * >(argp2);
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 (arg1)->SetMenu(arg2);
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 resultobj = SWIG_Py_Void();
42657 return resultobj;
42658 fail:
42659 return NULL;
42660 }
42661
42662
42663 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42664 PyObject *resultobj = 0;
42665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42666 int arg2 ;
42667 void *argp1 = 0 ;
42668 int res1 = 0 ;
42669 int val2 ;
42670 int ecode2 = 0 ;
42671 PyObject * obj0 = 0 ;
42672 PyObject * obj1 = 0 ;
42673 char * kwnames[] = {
42674 (char *) "self",(char *) "id", NULL
42675 };
42676
42677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42679 if (!SWIG_IsOK(res1)) {
42680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42681 }
42682 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42683 ecode2 = SWIG_AsVal_int(obj1, &val2);
42684 if (!SWIG_IsOK(ecode2)) {
42685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42686 }
42687 arg2 = static_cast< int >(val2);
42688 {
42689 PyThreadState* __tstate = wxPyBeginAllowThreads();
42690 (arg1)->SetId(arg2);
42691 wxPyEndAllowThreads(__tstate);
42692 if (PyErr_Occurred()) SWIG_fail;
42693 }
42694 resultobj = SWIG_Py_Void();
42695 return resultobj;
42696 fail:
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42702 PyObject *resultobj = 0;
42703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42704 int result;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 PyObject *swig_obj[1] ;
42708
42709 if (!args) SWIG_fail;
42710 swig_obj[0] = args;
42711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42712 if (!SWIG_IsOK(res1)) {
42713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42714 }
42715 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 result = (int)((wxMenuItem const *)arg1)->GetId();
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 resultobj = SWIG_From_int(static_cast< int >(result));
42723 return resultobj;
42724 fail:
42725 return NULL;
42726 }
42727
42728
42729 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42730 PyObject *resultobj = 0;
42731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42732 bool result;
42733 void *argp1 = 0 ;
42734 int res1 = 0 ;
42735 PyObject *swig_obj[1] ;
42736
42737 if (!args) SWIG_fail;
42738 swig_obj[0] = args;
42739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42740 if (!SWIG_IsOK(res1)) {
42741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42742 }
42743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42744 {
42745 PyThreadState* __tstate = wxPyBeginAllowThreads();
42746 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42747 wxPyEndAllowThreads(__tstate);
42748 if (PyErr_Occurred()) SWIG_fail;
42749 }
42750 {
42751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42752 }
42753 return resultobj;
42754 fail:
42755 return NULL;
42756 }
42757
42758
42759 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42760 PyObject *resultobj = 0;
42761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42762 wxString *arg2 = 0 ;
42763 void *argp1 = 0 ;
42764 int res1 = 0 ;
42765 bool temp2 = false ;
42766 PyObject * obj0 = 0 ;
42767 PyObject * obj1 = 0 ;
42768 char * kwnames[] = {
42769 (char *) "self",(char *) "str", NULL
42770 };
42771
42772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42774 if (!SWIG_IsOK(res1)) {
42775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42776 }
42777 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42778 {
42779 arg2 = wxString_in_helper(obj1);
42780 if (arg2 == NULL) SWIG_fail;
42781 temp2 = true;
42782 }
42783 {
42784 PyThreadState* __tstate = wxPyBeginAllowThreads();
42785 (arg1)->SetText((wxString const &)*arg2);
42786 wxPyEndAllowThreads(__tstate);
42787 if (PyErr_Occurred()) SWIG_fail;
42788 }
42789 resultobj = SWIG_Py_Void();
42790 {
42791 if (temp2)
42792 delete arg2;
42793 }
42794 return resultobj;
42795 fail:
42796 {
42797 if (temp2)
42798 delete arg2;
42799 }
42800 return NULL;
42801 }
42802
42803
42804 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42805 PyObject *resultobj = 0;
42806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42807 wxString result;
42808 void *argp1 = 0 ;
42809 int res1 = 0 ;
42810 PyObject *swig_obj[1] ;
42811
42812 if (!args) SWIG_fail;
42813 swig_obj[0] = args;
42814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42815 if (!SWIG_IsOK(res1)) {
42816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42817 }
42818 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42819 {
42820 PyThreadState* __tstate = wxPyBeginAllowThreads();
42821 result = ((wxMenuItem const *)arg1)->GetLabel();
42822 wxPyEndAllowThreads(__tstate);
42823 if (PyErr_Occurred()) SWIG_fail;
42824 }
42825 {
42826 #if wxUSE_UNICODE
42827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42828 #else
42829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42830 #endif
42831 }
42832 return resultobj;
42833 fail:
42834 return NULL;
42835 }
42836
42837
42838 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42839 PyObject *resultobj = 0;
42840 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42841 wxString *result = 0 ;
42842 void *argp1 = 0 ;
42843 int res1 = 0 ;
42844 PyObject *swig_obj[1] ;
42845
42846 if (!args) SWIG_fail;
42847 swig_obj[0] = args;
42848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42849 if (!SWIG_IsOK(res1)) {
42850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42851 }
42852 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42853 {
42854 PyThreadState* __tstate = wxPyBeginAllowThreads();
42855 {
42856 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42857 result = (wxString *) &_result_ref;
42858 }
42859 wxPyEndAllowThreads(__tstate);
42860 if (PyErr_Occurred()) SWIG_fail;
42861 }
42862 {
42863 #if wxUSE_UNICODE
42864 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42865 #else
42866 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42867 #endif
42868 }
42869 return resultobj;
42870 fail:
42871 return NULL;
42872 }
42873
42874
42875 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42876 PyObject *resultobj = 0;
42877 wxString *arg1 = 0 ;
42878 wxString result;
42879 bool temp1 = false ;
42880 PyObject * obj0 = 0 ;
42881 char * kwnames[] = {
42882 (char *) "text", NULL
42883 };
42884
42885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42886 {
42887 arg1 = wxString_in_helper(obj0);
42888 if (arg1 == NULL) SWIG_fail;
42889 temp1 = true;
42890 }
42891 {
42892 PyThreadState* __tstate = wxPyBeginAllowThreads();
42893 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42894 wxPyEndAllowThreads(__tstate);
42895 if (PyErr_Occurred()) SWIG_fail;
42896 }
42897 {
42898 #if wxUSE_UNICODE
42899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42900 #else
42901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42902 #endif
42903 }
42904 {
42905 if (temp1)
42906 delete arg1;
42907 }
42908 return resultobj;
42909 fail:
42910 {
42911 if (temp1)
42912 delete arg1;
42913 }
42914 return NULL;
42915 }
42916
42917
42918 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42919 PyObject *resultobj = 0;
42920 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42921 wxItemKind result;
42922 void *argp1 = 0 ;
42923 int res1 = 0 ;
42924 PyObject *swig_obj[1] ;
42925
42926 if (!args) SWIG_fail;
42927 swig_obj[0] = args;
42928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42929 if (!SWIG_IsOK(res1)) {
42930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42931 }
42932 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42933 {
42934 PyThreadState* __tstate = wxPyBeginAllowThreads();
42935 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42936 wxPyEndAllowThreads(__tstate);
42937 if (PyErr_Occurred()) SWIG_fail;
42938 }
42939 resultobj = SWIG_From_int(static_cast< int >(result));
42940 return resultobj;
42941 fail:
42942 return NULL;
42943 }
42944
42945
42946 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42947 PyObject *resultobj = 0;
42948 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42949 wxItemKind arg2 ;
42950 void *argp1 = 0 ;
42951 int res1 = 0 ;
42952 int val2 ;
42953 int ecode2 = 0 ;
42954 PyObject * obj0 = 0 ;
42955 PyObject * obj1 = 0 ;
42956 char * kwnames[] = {
42957 (char *) "self",(char *) "kind", NULL
42958 };
42959
42960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42962 if (!SWIG_IsOK(res1)) {
42963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42964 }
42965 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42966 ecode2 = SWIG_AsVal_int(obj1, &val2);
42967 if (!SWIG_IsOK(ecode2)) {
42968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42969 }
42970 arg2 = static_cast< wxItemKind >(val2);
42971 {
42972 PyThreadState* __tstate = wxPyBeginAllowThreads();
42973 (arg1)->SetKind(arg2);
42974 wxPyEndAllowThreads(__tstate);
42975 if (PyErr_Occurred()) SWIG_fail;
42976 }
42977 resultobj = SWIG_Py_Void();
42978 return resultobj;
42979 fail:
42980 return NULL;
42981 }
42982
42983
42984 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42985 PyObject *resultobj = 0;
42986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42987 bool arg2 ;
42988 void *argp1 = 0 ;
42989 int res1 = 0 ;
42990 bool val2 ;
42991 int ecode2 = 0 ;
42992 PyObject * obj0 = 0 ;
42993 PyObject * obj1 = 0 ;
42994 char * kwnames[] = {
42995 (char *) "self",(char *) "checkable", NULL
42996 };
42997
42998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43000 if (!SWIG_IsOK(res1)) {
43001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43002 }
43003 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43005 if (!SWIG_IsOK(ecode2)) {
43006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43007 }
43008 arg2 = static_cast< bool >(val2);
43009 {
43010 PyThreadState* __tstate = wxPyBeginAllowThreads();
43011 (arg1)->SetCheckable(arg2);
43012 wxPyEndAllowThreads(__tstate);
43013 if (PyErr_Occurred()) SWIG_fail;
43014 }
43015 resultobj = SWIG_Py_Void();
43016 return resultobj;
43017 fail:
43018 return NULL;
43019 }
43020
43021
43022 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43023 PyObject *resultobj = 0;
43024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43025 bool result;
43026 void *argp1 = 0 ;
43027 int res1 = 0 ;
43028 PyObject *swig_obj[1] ;
43029
43030 if (!args) SWIG_fail;
43031 swig_obj[0] = args;
43032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43033 if (!SWIG_IsOK(res1)) {
43034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43035 }
43036 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43037 {
43038 PyThreadState* __tstate = wxPyBeginAllowThreads();
43039 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 {
43044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43045 }
43046 return resultobj;
43047 fail:
43048 return NULL;
43049 }
43050
43051
43052 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43053 PyObject *resultobj = 0;
43054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43055 bool result;
43056 void *argp1 = 0 ;
43057 int res1 = 0 ;
43058 PyObject *swig_obj[1] ;
43059
43060 if (!args) SWIG_fail;
43061 swig_obj[0] = args;
43062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43063 if (!SWIG_IsOK(res1)) {
43064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43065 }
43066 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43067 {
43068 PyThreadState* __tstate = wxPyBeginAllowThreads();
43069 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43070 wxPyEndAllowThreads(__tstate);
43071 if (PyErr_Occurred()) SWIG_fail;
43072 }
43073 {
43074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43075 }
43076 return resultobj;
43077 fail:
43078 return NULL;
43079 }
43080
43081
43082 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43083 PyObject *resultobj = 0;
43084 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43085 wxMenu *arg2 = (wxMenu *) 0 ;
43086 void *argp1 = 0 ;
43087 int res1 = 0 ;
43088 void *argp2 = 0 ;
43089 int res2 = 0 ;
43090 PyObject * obj0 = 0 ;
43091 PyObject * obj1 = 0 ;
43092 char * kwnames[] = {
43093 (char *) "self",(char *) "menu", NULL
43094 };
43095
43096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43098 if (!SWIG_IsOK(res1)) {
43099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43100 }
43101 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43102 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43103 if (!SWIG_IsOK(res2)) {
43104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43105 }
43106 arg2 = reinterpret_cast< wxMenu * >(argp2);
43107 {
43108 PyThreadState* __tstate = wxPyBeginAllowThreads();
43109 (arg1)->SetSubMenu(arg2);
43110 wxPyEndAllowThreads(__tstate);
43111 if (PyErr_Occurred()) SWIG_fail;
43112 }
43113 resultobj = SWIG_Py_Void();
43114 return resultobj;
43115 fail:
43116 return NULL;
43117 }
43118
43119
43120 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43121 PyObject *resultobj = 0;
43122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43123 wxMenu *result = 0 ;
43124 void *argp1 = 0 ;
43125 int res1 = 0 ;
43126 PyObject *swig_obj[1] ;
43127
43128 if (!args) SWIG_fail;
43129 swig_obj[0] = args;
43130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43131 if (!SWIG_IsOK(res1)) {
43132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43133 }
43134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43135 {
43136 PyThreadState* __tstate = wxPyBeginAllowThreads();
43137 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43138 wxPyEndAllowThreads(__tstate);
43139 if (PyErr_Occurred()) SWIG_fail;
43140 }
43141 {
43142 resultobj = wxPyMake_wxObject(result, 0);
43143 }
43144 return resultobj;
43145 fail:
43146 return NULL;
43147 }
43148
43149
43150 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43151 PyObject *resultobj = 0;
43152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43153 bool arg2 = (bool) true ;
43154 void *argp1 = 0 ;
43155 int res1 = 0 ;
43156 bool val2 ;
43157 int ecode2 = 0 ;
43158 PyObject * obj0 = 0 ;
43159 PyObject * obj1 = 0 ;
43160 char * kwnames[] = {
43161 (char *) "self",(char *) "enable", NULL
43162 };
43163
43164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43166 if (!SWIG_IsOK(res1)) {
43167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43168 }
43169 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43170 if (obj1) {
43171 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43172 if (!SWIG_IsOK(ecode2)) {
43173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43174 }
43175 arg2 = static_cast< bool >(val2);
43176 }
43177 {
43178 PyThreadState* __tstate = wxPyBeginAllowThreads();
43179 (arg1)->Enable(arg2);
43180 wxPyEndAllowThreads(__tstate);
43181 if (PyErr_Occurred()) SWIG_fail;
43182 }
43183 resultobj = SWIG_Py_Void();
43184 return resultobj;
43185 fail:
43186 return NULL;
43187 }
43188
43189
43190 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43191 PyObject *resultobj = 0;
43192 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43193 bool result;
43194 void *argp1 = 0 ;
43195 int res1 = 0 ;
43196 PyObject *swig_obj[1] ;
43197
43198 if (!args) SWIG_fail;
43199 swig_obj[0] = args;
43200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43201 if (!SWIG_IsOK(res1)) {
43202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43203 }
43204 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43205 {
43206 PyThreadState* __tstate = wxPyBeginAllowThreads();
43207 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43208 wxPyEndAllowThreads(__tstate);
43209 if (PyErr_Occurred()) SWIG_fail;
43210 }
43211 {
43212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43213 }
43214 return resultobj;
43215 fail:
43216 return NULL;
43217 }
43218
43219
43220 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43221 PyObject *resultobj = 0;
43222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43223 bool arg2 = (bool) true ;
43224 void *argp1 = 0 ;
43225 int res1 = 0 ;
43226 bool val2 ;
43227 int ecode2 = 0 ;
43228 PyObject * obj0 = 0 ;
43229 PyObject * obj1 = 0 ;
43230 char * kwnames[] = {
43231 (char *) "self",(char *) "check", NULL
43232 };
43233
43234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43236 if (!SWIG_IsOK(res1)) {
43237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43238 }
43239 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43240 if (obj1) {
43241 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43242 if (!SWIG_IsOK(ecode2)) {
43243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43244 }
43245 arg2 = static_cast< bool >(val2);
43246 }
43247 {
43248 PyThreadState* __tstate = wxPyBeginAllowThreads();
43249 (arg1)->Check(arg2);
43250 wxPyEndAllowThreads(__tstate);
43251 if (PyErr_Occurred()) SWIG_fail;
43252 }
43253 resultobj = SWIG_Py_Void();
43254 return resultobj;
43255 fail:
43256 return NULL;
43257 }
43258
43259
43260 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43261 PyObject *resultobj = 0;
43262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43263 bool result;
43264 void *argp1 = 0 ;
43265 int res1 = 0 ;
43266 PyObject *swig_obj[1] ;
43267
43268 if (!args) SWIG_fail;
43269 swig_obj[0] = args;
43270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43271 if (!SWIG_IsOK(res1)) {
43272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43273 }
43274 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43275 {
43276 PyThreadState* __tstate = wxPyBeginAllowThreads();
43277 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 {
43282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43283 }
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43291 PyObject *resultobj = 0;
43292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43293 void *argp1 = 0 ;
43294 int res1 = 0 ;
43295 PyObject *swig_obj[1] ;
43296
43297 if (!args) SWIG_fail;
43298 swig_obj[0] = args;
43299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43300 if (!SWIG_IsOK(res1)) {
43301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43302 }
43303 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43304 {
43305 PyThreadState* __tstate = wxPyBeginAllowThreads();
43306 (arg1)->Toggle();
43307 wxPyEndAllowThreads(__tstate);
43308 if (PyErr_Occurred()) SWIG_fail;
43309 }
43310 resultobj = SWIG_Py_Void();
43311 return resultobj;
43312 fail:
43313 return NULL;
43314 }
43315
43316
43317 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43318 PyObject *resultobj = 0;
43319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43320 wxString *arg2 = 0 ;
43321 void *argp1 = 0 ;
43322 int res1 = 0 ;
43323 bool temp2 = false ;
43324 PyObject * obj0 = 0 ;
43325 PyObject * obj1 = 0 ;
43326 char * kwnames[] = {
43327 (char *) "self",(char *) "str", NULL
43328 };
43329
43330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43332 if (!SWIG_IsOK(res1)) {
43333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43334 }
43335 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43336 {
43337 arg2 = wxString_in_helper(obj1);
43338 if (arg2 == NULL) SWIG_fail;
43339 temp2 = true;
43340 }
43341 {
43342 PyThreadState* __tstate = wxPyBeginAllowThreads();
43343 (arg1)->SetHelp((wxString const &)*arg2);
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 resultobj = SWIG_Py_Void();
43348 {
43349 if (temp2)
43350 delete arg2;
43351 }
43352 return resultobj;
43353 fail:
43354 {
43355 if (temp2)
43356 delete arg2;
43357 }
43358 return NULL;
43359 }
43360
43361
43362 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43363 PyObject *resultobj = 0;
43364 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43365 wxString *result = 0 ;
43366 void *argp1 = 0 ;
43367 int res1 = 0 ;
43368 PyObject *swig_obj[1] ;
43369
43370 if (!args) SWIG_fail;
43371 swig_obj[0] = args;
43372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43373 if (!SWIG_IsOK(res1)) {
43374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43375 }
43376 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43377 {
43378 PyThreadState* __tstate = wxPyBeginAllowThreads();
43379 {
43380 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43381 result = (wxString *) &_result_ref;
43382 }
43383 wxPyEndAllowThreads(__tstate);
43384 if (PyErr_Occurred()) SWIG_fail;
43385 }
43386 {
43387 #if wxUSE_UNICODE
43388 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43389 #else
43390 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43391 #endif
43392 }
43393 return resultobj;
43394 fail:
43395 return NULL;
43396 }
43397
43398
43399 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43400 PyObject *resultobj = 0;
43401 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43402 wxAcceleratorEntry *result = 0 ;
43403 void *argp1 = 0 ;
43404 int res1 = 0 ;
43405 PyObject *swig_obj[1] ;
43406
43407 if (!args) SWIG_fail;
43408 swig_obj[0] = args;
43409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43410 if (!SWIG_IsOK(res1)) {
43411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43412 }
43413 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43414 {
43415 PyThreadState* __tstate = wxPyBeginAllowThreads();
43416 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43417 wxPyEndAllowThreads(__tstate);
43418 if (PyErr_Occurred()) SWIG_fail;
43419 }
43420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43421 return resultobj;
43422 fail:
43423 return NULL;
43424 }
43425
43426
43427 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43428 PyObject *resultobj = 0;
43429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43430 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43431 void *argp1 = 0 ;
43432 int res1 = 0 ;
43433 void *argp2 = 0 ;
43434 int res2 = 0 ;
43435 PyObject * obj0 = 0 ;
43436 PyObject * obj1 = 0 ;
43437 char * kwnames[] = {
43438 (char *) "self",(char *) "accel", NULL
43439 };
43440
43441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43443 if (!SWIG_IsOK(res1)) {
43444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43445 }
43446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43447 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43448 if (!SWIG_IsOK(res2)) {
43449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43450 }
43451 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43452 {
43453 PyThreadState* __tstate = wxPyBeginAllowThreads();
43454 (arg1)->SetAccel(arg2);
43455 wxPyEndAllowThreads(__tstate);
43456 if (PyErr_Occurred()) SWIG_fail;
43457 }
43458 resultobj = SWIG_Py_Void();
43459 return resultobj;
43460 fail:
43461 return NULL;
43462 }
43463
43464
43465 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43466 PyObject *resultobj = 0;
43467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43468 wxBitmap *arg2 = 0 ;
43469 void *argp1 = 0 ;
43470 int res1 = 0 ;
43471 void *argp2 = 0 ;
43472 int res2 = 0 ;
43473 PyObject * obj0 = 0 ;
43474 PyObject * obj1 = 0 ;
43475 char * kwnames[] = {
43476 (char *) "self",(char *) "bitmap", NULL
43477 };
43478
43479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43481 if (!SWIG_IsOK(res1)) {
43482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43483 }
43484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43486 if (!SWIG_IsOK(res2)) {
43487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43488 }
43489 if (!argp2) {
43490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43491 }
43492 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43493 {
43494 PyThreadState* __tstate = wxPyBeginAllowThreads();
43495 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43496 wxPyEndAllowThreads(__tstate);
43497 if (PyErr_Occurred()) SWIG_fail;
43498 }
43499 resultobj = SWIG_Py_Void();
43500 return resultobj;
43501 fail:
43502 return NULL;
43503 }
43504
43505
43506 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43507 PyObject *resultobj = 0;
43508 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43509 wxBitmap *result = 0 ;
43510 void *argp1 = 0 ;
43511 int res1 = 0 ;
43512 PyObject *swig_obj[1] ;
43513
43514 if (!args) SWIG_fail;
43515 swig_obj[0] = args;
43516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43517 if (!SWIG_IsOK(res1)) {
43518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43519 }
43520 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43521 {
43522 PyThreadState* __tstate = wxPyBeginAllowThreads();
43523 {
43524 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43525 result = (wxBitmap *) &_result_ref;
43526 }
43527 wxPyEndAllowThreads(__tstate);
43528 if (PyErr_Occurred()) SWIG_fail;
43529 }
43530 {
43531 wxBitmap* resultptr = new wxBitmap(*result);
43532 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43533 }
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43541 PyObject *resultobj = 0;
43542 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43543 wxFont *arg2 = 0 ;
43544 void *argp1 = 0 ;
43545 int res1 = 0 ;
43546 void *argp2 = 0 ;
43547 int res2 = 0 ;
43548 PyObject * obj0 = 0 ;
43549 PyObject * obj1 = 0 ;
43550 char * kwnames[] = {
43551 (char *) "self",(char *) "font", NULL
43552 };
43553
43554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43556 if (!SWIG_IsOK(res1)) {
43557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43558 }
43559 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43561 if (!SWIG_IsOK(res2)) {
43562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43563 }
43564 if (!argp2) {
43565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43566 }
43567 arg2 = reinterpret_cast< wxFont * >(argp2);
43568 {
43569 PyThreadState* __tstate = wxPyBeginAllowThreads();
43570 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43571 wxPyEndAllowThreads(__tstate);
43572 if (PyErr_Occurred()) SWIG_fail;
43573 }
43574 resultobj = SWIG_Py_Void();
43575 return resultobj;
43576 fail:
43577 return NULL;
43578 }
43579
43580
43581 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43582 PyObject *resultobj = 0;
43583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43584 wxFont result;
43585 void *argp1 = 0 ;
43586 int res1 = 0 ;
43587 PyObject *swig_obj[1] ;
43588
43589 if (!args) SWIG_fail;
43590 swig_obj[0] = args;
43591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43592 if (!SWIG_IsOK(res1)) {
43593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43594 }
43595 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43596 {
43597 PyThreadState* __tstate = wxPyBeginAllowThreads();
43598 result = wxMenuItem_GetFont(arg1);
43599 wxPyEndAllowThreads(__tstate);
43600 if (PyErr_Occurred()) SWIG_fail;
43601 }
43602 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43603 return resultobj;
43604 fail:
43605 return NULL;
43606 }
43607
43608
43609 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43610 PyObject *resultobj = 0;
43611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43612 wxColour *arg2 = 0 ;
43613 void *argp1 = 0 ;
43614 int res1 = 0 ;
43615 wxColour temp2 ;
43616 PyObject * obj0 = 0 ;
43617 PyObject * obj1 = 0 ;
43618 char * kwnames[] = {
43619 (char *) "self",(char *) "colText", NULL
43620 };
43621
43622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43624 if (!SWIG_IsOK(res1)) {
43625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43626 }
43627 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43628 {
43629 arg2 = &temp2;
43630 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43631 }
43632 {
43633 PyThreadState* __tstate = wxPyBeginAllowThreads();
43634 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43635 wxPyEndAllowThreads(__tstate);
43636 if (PyErr_Occurred()) SWIG_fail;
43637 }
43638 resultobj = SWIG_Py_Void();
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43646 PyObject *resultobj = 0;
43647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43648 wxColour result;
43649 void *argp1 = 0 ;
43650 int res1 = 0 ;
43651 PyObject *swig_obj[1] ;
43652
43653 if (!args) SWIG_fail;
43654 swig_obj[0] = args;
43655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43656 if (!SWIG_IsOK(res1)) {
43657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43658 }
43659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = wxMenuItem_GetTextColour(arg1);
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43667 return resultobj;
43668 fail:
43669 return NULL;
43670 }
43671
43672
43673 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43674 PyObject *resultobj = 0;
43675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43676 wxColour *arg2 = 0 ;
43677 void *argp1 = 0 ;
43678 int res1 = 0 ;
43679 wxColour temp2 ;
43680 PyObject * obj0 = 0 ;
43681 PyObject * obj1 = 0 ;
43682 char * kwnames[] = {
43683 (char *) "self",(char *) "colBack", NULL
43684 };
43685
43686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43688 if (!SWIG_IsOK(res1)) {
43689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43690 }
43691 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43692 {
43693 arg2 = &temp2;
43694 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43695 }
43696 {
43697 PyThreadState* __tstate = wxPyBeginAllowThreads();
43698 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43699 wxPyEndAllowThreads(__tstate);
43700 if (PyErr_Occurred()) SWIG_fail;
43701 }
43702 resultobj = SWIG_Py_Void();
43703 return resultobj;
43704 fail:
43705 return NULL;
43706 }
43707
43708
43709 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43710 PyObject *resultobj = 0;
43711 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43712 wxColour result;
43713 void *argp1 = 0 ;
43714 int res1 = 0 ;
43715 PyObject *swig_obj[1] ;
43716
43717 if (!args) SWIG_fail;
43718 swig_obj[0] = args;
43719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43720 if (!SWIG_IsOK(res1)) {
43721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43722 }
43723 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43724 {
43725 PyThreadState* __tstate = wxPyBeginAllowThreads();
43726 result = wxMenuItem_GetBackgroundColour(arg1);
43727 wxPyEndAllowThreads(__tstate);
43728 if (PyErr_Occurred()) SWIG_fail;
43729 }
43730 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43731 return resultobj;
43732 fail:
43733 return NULL;
43734 }
43735
43736
43737 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43738 PyObject *resultobj = 0;
43739 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43740 wxBitmap *arg2 = 0 ;
43741 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43742 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43743 void *argp1 = 0 ;
43744 int res1 = 0 ;
43745 void *argp2 = 0 ;
43746 int res2 = 0 ;
43747 void *argp3 = 0 ;
43748 int res3 = 0 ;
43749 PyObject * obj0 = 0 ;
43750 PyObject * obj1 = 0 ;
43751 PyObject * obj2 = 0 ;
43752 char * kwnames[] = {
43753 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43754 };
43755
43756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43758 if (!SWIG_IsOK(res1)) {
43759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43760 }
43761 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43763 if (!SWIG_IsOK(res2)) {
43764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43765 }
43766 if (!argp2) {
43767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43768 }
43769 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43770 if (obj2) {
43771 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43772 if (!SWIG_IsOK(res3)) {
43773 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43774 }
43775 if (!argp3) {
43776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43777 }
43778 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43779 }
43780 {
43781 PyThreadState* __tstate = wxPyBeginAllowThreads();
43782 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43783 wxPyEndAllowThreads(__tstate);
43784 if (PyErr_Occurred()) SWIG_fail;
43785 }
43786 resultobj = SWIG_Py_Void();
43787 return resultobj;
43788 fail:
43789 return NULL;
43790 }
43791
43792
43793 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43794 PyObject *resultobj = 0;
43795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43796 wxBitmap *arg2 = 0 ;
43797 void *argp1 = 0 ;
43798 int res1 = 0 ;
43799 void *argp2 = 0 ;
43800 int res2 = 0 ;
43801 PyObject * obj0 = 0 ;
43802 PyObject * obj1 = 0 ;
43803 char * kwnames[] = {
43804 (char *) "self",(char *) "bmpDisabled", NULL
43805 };
43806
43807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43809 if (!SWIG_IsOK(res1)) {
43810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43811 }
43812 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43814 if (!SWIG_IsOK(res2)) {
43815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43816 }
43817 if (!argp2) {
43818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43819 }
43820 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43821 {
43822 PyThreadState* __tstate = wxPyBeginAllowThreads();
43823 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43824 wxPyEndAllowThreads(__tstate);
43825 if (PyErr_Occurred()) SWIG_fail;
43826 }
43827 resultobj = SWIG_Py_Void();
43828 return resultobj;
43829 fail:
43830 return NULL;
43831 }
43832
43833
43834 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43835 PyObject *resultobj = 0;
43836 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43837 wxBitmap *result = 0 ;
43838 void *argp1 = 0 ;
43839 int res1 = 0 ;
43840 PyObject *swig_obj[1] ;
43841
43842 if (!args) SWIG_fail;
43843 swig_obj[0] = args;
43844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43845 if (!SWIG_IsOK(res1)) {
43846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43847 }
43848 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43849 {
43850 PyThreadState* __tstate = wxPyBeginAllowThreads();
43851 {
43852 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43853 result = (wxBitmap *) &_result_ref;
43854 }
43855 wxPyEndAllowThreads(__tstate);
43856 if (PyErr_Occurred()) SWIG_fail;
43857 }
43858 {
43859 wxBitmap* resultptr = new wxBitmap(*result);
43860 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43861 }
43862 return resultobj;
43863 fail:
43864 return NULL;
43865 }
43866
43867
43868 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43869 PyObject *resultobj = 0;
43870 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43871 int arg2 ;
43872 void *argp1 = 0 ;
43873 int res1 = 0 ;
43874 int val2 ;
43875 int ecode2 = 0 ;
43876 PyObject * obj0 = 0 ;
43877 PyObject * obj1 = 0 ;
43878 char * kwnames[] = {
43879 (char *) "self",(char *) "nWidth", NULL
43880 };
43881
43882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43884 if (!SWIG_IsOK(res1)) {
43885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43886 }
43887 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43888 ecode2 = SWIG_AsVal_int(obj1, &val2);
43889 if (!SWIG_IsOK(ecode2)) {
43890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43891 }
43892 arg2 = static_cast< int >(val2);
43893 {
43894 PyThreadState* __tstate = wxPyBeginAllowThreads();
43895 wxMenuItem_SetMarginWidth(arg1,arg2);
43896 wxPyEndAllowThreads(__tstate);
43897 if (PyErr_Occurred()) SWIG_fail;
43898 }
43899 resultobj = SWIG_Py_Void();
43900 return resultobj;
43901 fail:
43902 return NULL;
43903 }
43904
43905
43906 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43907 PyObject *resultobj = 0;
43908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43909 int result;
43910 void *argp1 = 0 ;
43911 int res1 = 0 ;
43912 PyObject *swig_obj[1] ;
43913
43914 if (!args) SWIG_fail;
43915 swig_obj[0] = args;
43916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43917 if (!SWIG_IsOK(res1)) {
43918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43919 }
43920 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43921 {
43922 PyThreadState* __tstate = wxPyBeginAllowThreads();
43923 result = (int)wxMenuItem_GetMarginWidth(arg1);
43924 wxPyEndAllowThreads(__tstate);
43925 if (PyErr_Occurred()) SWIG_fail;
43926 }
43927 resultobj = SWIG_From_int(static_cast< int >(result));
43928 return resultobj;
43929 fail:
43930 return NULL;
43931 }
43932
43933
43934 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43935 PyObject *resultobj = 0;
43936 int result;
43937
43938 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43939 {
43940 PyThreadState* __tstate = wxPyBeginAllowThreads();
43941 result = (int)wxMenuItem_GetDefaultMarginWidth();
43942 wxPyEndAllowThreads(__tstate);
43943 if (PyErr_Occurred()) SWIG_fail;
43944 }
43945 resultobj = SWIG_From_int(static_cast< int >(result));
43946 return resultobj;
43947 fail:
43948 return NULL;
43949 }
43950
43951
43952 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43953 PyObject *resultobj = 0;
43954 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43955 bool result;
43956 void *argp1 = 0 ;
43957 int res1 = 0 ;
43958 PyObject *swig_obj[1] ;
43959
43960 if (!args) SWIG_fail;
43961 swig_obj[0] = args;
43962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43963 if (!SWIG_IsOK(res1)) {
43964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43965 }
43966 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43967 {
43968 PyThreadState* __tstate = wxPyBeginAllowThreads();
43969 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43970 wxPyEndAllowThreads(__tstate);
43971 if (PyErr_Occurred()) SWIG_fail;
43972 }
43973 {
43974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43975 }
43976 return resultobj;
43977 fail:
43978 return NULL;
43979 }
43980
43981
43982 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43983 PyObject *resultobj = 0;
43984 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43985 bool arg2 = (bool) true ;
43986 void *argp1 = 0 ;
43987 int res1 = 0 ;
43988 bool val2 ;
43989 int ecode2 = 0 ;
43990 PyObject * obj0 = 0 ;
43991 PyObject * obj1 = 0 ;
43992 char * kwnames[] = {
43993 (char *) "self",(char *) "ownerDrawn", NULL
43994 };
43995
43996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43998 if (!SWIG_IsOK(res1)) {
43999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44000 }
44001 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44002 if (obj1) {
44003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44004 if (!SWIG_IsOK(ecode2)) {
44005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44006 }
44007 arg2 = static_cast< bool >(val2);
44008 }
44009 {
44010 PyThreadState* __tstate = wxPyBeginAllowThreads();
44011 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44012 wxPyEndAllowThreads(__tstate);
44013 if (PyErr_Occurred()) SWIG_fail;
44014 }
44015 resultobj = SWIG_Py_Void();
44016 return resultobj;
44017 fail:
44018 return NULL;
44019 }
44020
44021
44022 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44023 PyObject *resultobj = 0;
44024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44025 void *argp1 = 0 ;
44026 int res1 = 0 ;
44027 PyObject *swig_obj[1] ;
44028
44029 if (!args) SWIG_fail;
44030 swig_obj[0] = args;
44031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44032 if (!SWIG_IsOK(res1)) {
44033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44034 }
44035 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 wxMenuItem_ResetOwnerDrawn(arg1);
44039 wxPyEndAllowThreads(__tstate);
44040 if (PyErr_Occurred()) SWIG_fail;
44041 }
44042 resultobj = SWIG_Py_Void();
44043 return resultobj;
44044 fail:
44045 return NULL;
44046 }
44047
44048
44049 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44050 PyObject *obj;
44051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44052 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44053 return SWIG_Py_Void();
44054 }
44055
44056 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44057 return SWIG_Python_InitShadowInstance(args);
44058 }
44059
44060 SWIGINTERN int ControlNameStr_set(PyObject *) {
44061 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44062 return 1;
44063 }
44064
44065
44066 SWIGINTERN PyObject *ControlNameStr_get(void) {
44067 PyObject *pyobj = 0;
44068
44069 {
44070 #if wxUSE_UNICODE
44071 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44072 #else
44073 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44074 #endif
44075 }
44076 return pyobj;
44077 }
44078
44079
44080 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44081 PyObject *resultobj = 0;
44082 wxWindow *arg1 = (wxWindow *) 0 ;
44083 int arg2 = (int) -1 ;
44084 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44085 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44086 wxSize const &arg4_defvalue = wxDefaultSize ;
44087 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44088 long arg5 = (long) 0 ;
44089 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44090 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44091 wxString const &arg7_defvalue = wxPyControlNameStr ;
44092 wxString *arg7 = (wxString *) &arg7_defvalue ;
44093 wxControl *result = 0 ;
44094 void *argp1 = 0 ;
44095 int res1 = 0 ;
44096 int val2 ;
44097 int ecode2 = 0 ;
44098 wxPoint temp3 ;
44099 wxSize temp4 ;
44100 long val5 ;
44101 int ecode5 = 0 ;
44102 void *argp6 = 0 ;
44103 int res6 = 0 ;
44104 bool temp7 = false ;
44105 PyObject * obj0 = 0 ;
44106 PyObject * obj1 = 0 ;
44107 PyObject * obj2 = 0 ;
44108 PyObject * obj3 = 0 ;
44109 PyObject * obj4 = 0 ;
44110 PyObject * obj5 = 0 ;
44111 PyObject * obj6 = 0 ;
44112 char * kwnames[] = {
44113 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44114 };
44115
44116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44118 if (!SWIG_IsOK(res1)) {
44119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44120 }
44121 arg1 = reinterpret_cast< wxWindow * >(argp1);
44122 if (obj1) {
44123 ecode2 = SWIG_AsVal_int(obj1, &val2);
44124 if (!SWIG_IsOK(ecode2)) {
44125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44126 }
44127 arg2 = static_cast< int >(val2);
44128 }
44129 if (obj2) {
44130 {
44131 arg3 = &temp3;
44132 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44133 }
44134 }
44135 if (obj3) {
44136 {
44137 arg4 = &temp4;
44138 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44139 }
44140 }
44141 if (obj4) {
44142 ecode5 = SWIG_AsVal_long(obj4, &val5);
44143 if (!SWIG_IsOK(ecode5)) {
44144 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44145 }
44146 arg5 = static_cast< long >(val5);
44147 }
44148 if (obj5) {
44149 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44150 if (!SWIG_IsOK(res6)) {
44151 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44152 }
44153 if (!argp6) {
44154 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44155 }
44156 arg6 = reinterpret_cast< wxValidator * >(argp6);
44157 }
44158 if (obj6) {
44159 {
44160 arg7 = wxString_in_helper(obj6);
44161 if (arg7 == NULL) SWIG_fail;
44162 temp7 = true;
44163 }
44164 }
44165 {
44166 if (!wxPyCheckForApp()) SWIG_fail;
44167 PyThreadState* __tstate = wxPyBeginAllowThreads();
44168 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44169 wxPyEndAllowThreads(__tstate);
44170 if (PyErr_Occurred()) SWIG_fail;
44171 }
44172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44173 {
44174 if (temp7)
44175 delete arg7;
44176 }
44177 return resultobj;
44178 fail:
44179 {
44180 if (temp7)
44181 delete arg7;
44182 }
44183 return NULL;
44184 }
44185
44186
44187 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44188 PyObject *resultobj = 0;
44189 wxControl *result = 0 ;
44190
44191 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44192 {
44193 if (!wxPyCheckForApp()) SWIG_fail;
44194 PyThreadState* __tstate = wxPyBeginAllowThreads();
44195 result = (wxControl *)new wxControl();
44196 wxPyEndAllowThreads(__tstate);
44197 if (PyErr_Occurred()) SWIG_fail;
44198 }
44199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44200 return resultobj;
44201 fail:
44202 return NULL;
44203 }
44204
44205
44206 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44207 PyObject *resultobj = 0;
44208 wxControl *arg1 = (wxControl *) 0 ;
44209 wxWindow *arg2 = (wxWindow *) 0 ;
44210 int arg3 = (int) -1 ;
44211 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44212 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44213 wxSize const &arg5_defvalue = wxDefaultSize ;
44214 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44215 long arg6 = (long) 0 ;
44216 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44217 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44218 wxString const &arg8_defvalue = wxPyControlNameStr ;
44219 wxString *arg8 = (wxString *) &arg8_defvalue ;
44220 bool result;
44221 void *argp1 = 0 ;
44222 int res1 = 0 ;
44223 void *argp2 = 0 ;
44224 int res2 = 0 ;
44225 int val3 ;
44226 int ecode3 = 0 ;
44227 wxPoint temp4 ;
44228 wxSize temp5 ;
44229 long val6 ;
44230 int ecode6 = 0 ;
44231 void *argp7 = 0 ;
44232 int res7 = 0 ;
44233 bool temp8 = false ;
44234 PyObject * obj0 = 0 ;
44235 PyObject * obj1 = 0 ;
44236 PyObject * obj2 = 0 ;
44237 PyObject * obj3 = 0 ;
44238 PyObject * obj4 = 0 ;
44239 PyObject * obj5 = 0 ;
44240 PyObject * obj6 = 0 ;
44241 PyObject * obj7 = 0 ;
44242 char * kwnames[] = {
44243 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44244 };
44245
44246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44248 if (!SWIG_IsOK(res1)) {
44249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44250 }
44251 arg1 = reinterpret_cast< wxControl * >(argp1);
44252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44253 if (!SWIG_IsOK(res2)) {
44254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44255 }
44256 arg2 = reinterpret_cast< wxWindow * >(argp2);
44257 if (obj2) {
44258 ecode3 = SWIG_AsVal_int(obj2, &val3);
44259 if (!SWIG_IsOK(ecode3)) {
44260 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44261 }
44262 arg3 = static_cast< int >(val3);
44263 }
44264 if (obj3) {
44265 {
44266 arg4 = &temp4;
44267 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44268 }
44269 }
44270 if (obj4) {
44271 {
44272 arg5 = &temp5;
44273 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44274 }
44275 }
44276 if (obj5) {
44277 ecode6 = SWIG_AsVal_long(obj5, &val6);
44278 if (!SWIG_IsOK(ecode6)) {
44279 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44280 }
44281 arg6 = static_cast< long >(val6);
44282 }
44283 if (obj6) {
44284 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44285 if (!SWIG_IsOK(res7)) {
44286 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44287 }
44288 if (!argp7) {
44289 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44290 }
44291 arg7 = reinterpret_cast< wxValidator * >(argp7);
44292 }
44293 if (obj7) {
44294 {
44295 arg8 = wxString_in_helper(obj7);
44296 if (arg8 == NULL) SWIG_fail;
44297 temp8 = true;
44298 }
44299 }
44300 {
44301 PyThreadState* __tstate = wxPyBeginAllowThreads();
44302 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44303 wxPyEndAllowThreads(__tstate);
44304 if (PyErr_Occurred()) SWIG_fail;
44305 }
44306 {
44307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44308 }
44309 {
44310 if (temp8)
44311 delete arg8;
44312 }
44313 return resultobj;
44314 fail:
44315 {
44316 if (temp8)
44317 delete arg8;
44318 }
44319 return NULL;
44320 }
44321
44322
44323 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44324 PyObject *resultobj = 0;
44325 wxControl *arg1 = (wxControl *) 0 ;
44326 int result;
44327 void *argp1 = 0 ;
44328 int res1 = 0 ;
44329 PyObject *swig_obj[1] ;
44330
44331 if (!args) SWIG_fail;
44332 swig_obj[0] = args;
44333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44334 if (!SWIG_IsOK(res1)) {
44335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44336 }
44337 arg1 = reinterpret_cast< wxControl * >(argp1);
44338 {
44339 PyThreadState* __tstate = wxPyBeginAllowThreads();
44340 result = (int)((wxControl const *)arg1)->GetAlignment();
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 resultobj = SWIG_From_int(static_cast< int >(result));
44345 return resultobj;
44346 fail:
44347 return NULL;
44348 }
44349
44350
44351 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44352 PyObject *resultobj = 0;
44353 wxControl *arg1 = (wxControl *) 0 ;
44354 wxString result;
44355 void *argp1 = 0 ;
44356 int res1 = 0 ;
44357 PyObject *swig_obj[1] ;
44358
44359 if (!args) SWIG_fail;
44360 swig_obj[0] = args;
44361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44362 if (!SWIG_IsOK(res1)) {
44363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44364 }
44365 arg1 = reinterpret_cast< wxControl * >(argp1);
44366 {
44367 PyThreadState* __tstate = wxPyBeginAllowThreads();
44368 result = ((wxControl const *)arg1)->GetLabelText();
44369 wxPyEndAllowThreads(__tstate);
44370 if (PyErr_Occurred()) SWIG_fail;
44371 }
44372 {
44373 #if wxUSE_UNICODE
44374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44375 #else
44376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44377 #endif
44378 }
44379 return resultobj;
44380 fail:
44381 return NULL;
44382 }
44383
44384
44385 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44386 PyObject *resultobj = 0;
44387 wxControl *arg1 = (wxControl *) 0 ;
44388 wxCommandEvent *arg2 = 0 ;
44389 void *argp1 = 0 ;
44390 int res1 = 0 ;
44391 void *argp2 = 0 ;
44392 int res2 = 0 ;
44393 PyObject * obj0 = 0 ;
44394 PyObject * obj1 = 0 ;
44395 char * kwnames[] = {
44396 (char *) "self",(char *) "event", NULL
44397 };
44398
44399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44401 if (!SWIG_IsOK(res1)) {
44402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44403 }
44404 arg1 = reinterpret_cast< wxControl * >(argp1);
44405 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44406 if (!SWIG_IsOK(res2)) {
44407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44408 }
44409 if (!argp2) {
44410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44411 }
44412 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44413 {
44414 PyThreadState* __tstate = wxPyBeginAllowThreads();
44415 (arg1)->Command(*arg2);
44416 wxPyEndAllowThreads(__tstate);
44417 if (PyErr_Occurred()) SWIG_fail;
44418 }
44419 resultobj = SWIG_Py_Void();
44420 return resultobj;
44421 fail:
44422 return NULL;
44423 }
44424
44425
44426 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44427 PyObject *resultobj = 0;
44428 wxControl *arg1 = (wxControl *) 0 ;
44429 wxString result;
44430 void *argp1 = 0 ;
44431 int res1 = 0 ;
44432 PyObject *swig_obj[1] ;
44433
44434 if (!args) SWIG_fail;
44435 swig_obj[0] = args;
44436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44437 if (!SWIG_IsOK(res1)) {
44438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44439 }
44440 arg1 = reinterpret_cast< wxControl * >(argp1);
44441 {
44442 PyThreadState* __tstate = wxPyBeginAllowThreads();
44443 result = (arg1)->GetLabel();
44444 wxPyEndAllowThreads(__tstate);
44445 if (PyErr_Occurred()) SWIG_fail;
44446 }
44447 {
44448 #if wxUSE_UNICODE
44449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44450 #else
44451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44452 #endif
44453 }
44454 return resultobj;
44455 fail:
44456 return NULL;
44457 }
44458
44459
44460 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44461 PyObject *resultobj = 0;
44462 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44463 SwigValueWrapper<wxVisualAttributes > result;
44464 int val1 ;
44465 int ecode1 = 0 ;
44466 PyObject * obj0 = 0 ;
44467 char * kwnames[] = {
44468 (char *) "variant", NULL
44469 };
44470
44471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44472 if (obj0) {
44473 ecode1 = SWIG_AsVal_int(obj0, &val1);
44474 if (!SWIG_IsOK(ecode1)) {
44475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44476 }
44477 arg1 = static_cast< wxWindowVariant >(val1);
44478 }
44479 {
44480 if (!wxPyCheckForApp()) SWIG_fail;
44481 PyThreadState* __tstate = wxPyBeginAllowThreads();
44482 result = wxControl::GetClassDefaultAttributes(arg1);
44483 wxPyEndAllowThreads(__tstate);
44484 if (PyErr_Occurred()) SWIG_fail;
44485 }
44486 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44487 return resultobj;
44488 fail:
44489 return NULL;
44490 }
44491
44492
44493 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44494 PyObject *obj;
44495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44496 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44497 return SWIG_Py_Void();
44498 }
44499
44500 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44501 return SWIG_Python_InitShadowInstance(args);
44502 }
44503
44504 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44505 PyObject *resultobj = 0;
44506 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44507 wxString *arg2 = 0 ;
44508 PyObject *arg3 = (PyObject *) NULL ;
44509 int result;
44510 void *argp1 = 0 ;
44511 int res1 = 0 ;
44512 bool temp2 = false ;
44513 PyObject * obj0 = 0 ;
44514 PyObject * obj1 = 0 ;
44515 PyObject * obj2 = 0 ;
44516 char * kwnames[] = {
44517 (char *) "self",(char *) "item",(char *) "clientData", NULL
44518 };
44519
44520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44522 if (!SWIG_IsOK(res1)) {
44523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44524 }
44525 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44526 {
44527 arg2 = wxString_in_helper(obj1);
44528 if (arg2 == NULL) SWIG_fail;
44529 temp2 = true;
44530 }
44531 if (obj2) {
44532 arg3 = obj2;
44533 }
44534 {
44535 PyThreadState* __tstate = wxPyBeginAllowThreads();
44536 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44537 wxPyEndAllowThreads(__tstate);
44538 if (PyErr_Occurred()) SWIG_fail;
44539 }
44540 resultobj = SWIG_From_int(static_cast< int >(result));
44541 {
44542 if (temp2)
44543 delete arg2;
44544 }
44545 return resultobj;
44546 fail:
44547 {
44548 if (temp2)
44549 delete arg2;
44550 }
44551 return NULL;
44552 }
44553
44554
44555 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44556 PyObject *resultobj = 0;
44557 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44558 wxArrayString *arg2 = 0 ;
44559 void *argp1 = 0 ;
44560 int res1 = 0 ;
44561 bool temp2 = false ;
44562 PyObject * obj0 = 0 ;
44563 PyObject * obj1 = 0 ;
44564 char * kwnames[] = {
44565 (char *) "self",(char *) "strings", NULL
44566 };
44567
44568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44570 if (!SWIG_IsOK(res1)) {
44571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44572 }
44573 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44574 {
44575 if (! PySequence_Check(obj1)) {
44576 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44577 SWIG_fail;
44578 }
44579 arg2 = new wxArrayString;
44580 temp2 = true;
44581 int i, len=PySequence_Length(obj1);
44582 for (i=0; i<len; i++) {
44583 PyObject* item = PySequence_GetItem(obj1, i);
44584 wxString* s = wxString_in_helper(item);
44585 if (PyErr_Occurred()) SWIG_fail;
44586 arg2->Add(*s);
44587 delete s;
44588 Py_DECREF(item);
44589 }
44590 }
44591 {
44592 PyThreadState* __tstate = wxPyBeginAllowThreads();
44593 (arg1)->Append((wxArrayString const &)*arg2);
44594 wxPyEndAllowThreads(__tstate);
44595 if (PyErr_Occurred()) SWIG_fail;
44596 }
44597 resultobj = SWIG_Py_Void();
44598 {
44599 if (temp2) delete arg2;
44600 }
44601 return resultobj;
44602 fail:
44603 {
44604 if (temp2) delete arg2;
44605 }
44606 return NULL;
44607 }
44608
44609
44610 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44611 PyObject *resultobj = 0;
44612 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44613 wxString *arg2 = 0 ;
44614 unsigned int arg3 ;
44615 PyObject *arg4 = (PyObject *) NULL ;
44616 int result;
44617 void *argp1 = 0 ;
44618 int res1 = 0 ;
44619 bool temp2 = false ;
44620 unsigned int val3 ;
44621 int ecode3 = 0 ;
44622 PyObject * obj0 = 0 ;
44623 PyObject * obj1 = 0 ;
44624 PyObject * obj2 = 0 ;
44625 PyObject * obj3 = 0 ;
44626 char * kwnames[] = {
44627 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44628 };
44629
44630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44632 if (!SWIG_IsOK(res1)) {
44633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44634 }
44635 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44636 {
44637 arg2 = wxString_in_helper(obj1);
44638 if (arg2 == NULL) SWIG_fail;
44639 temp2 = true;
44640 }
44641 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44642 if (!SWIG_IsOK(ecode3)) {
44643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44644 }
44645 arg3 = static_cast< unsigned int >(val3);
44646 if (obj3) {
44647 arg4 = obj3;
44648 }
44649 {
44650 PyThreadState* __tstate = wxPyBeginAllowThreads();
44651 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44652 wxPyEndAllowThreads(__tstate);
44653 if (PyErr_Occurred()) SWIG_fail;
44654 }
44655 resultobj = SWIG_From_int(static_cast< int >(result));
44656 {
44657 if (temp2)
44658 delete arg2;
44659 }
44660 return resultobj;
44661 fail:
44662 {
44663 if (temp2)
44664 delete arg2;
44665 }
44666 return NULL;
44667 }
44668
44669
44670 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44671 PyObject *resultobj = 0;
44672 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44673 void *argp1 = 0 ;
44674 int res1 = 0 ;
44675 PyObject *swig_obj[1] ;
44676
44677 if (!args) SWIG_fail;
44678 swig_obj[0] = args;
44679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44680 if (!SWIG_IsOK(res1)) {
44681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44682 }
44683 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44684 {
44685 PyThreadState* __tstate = wxPyBeginAllowThreads();
44686 (arg1)->Clear();
44687 wxPyEndAllowThreads(__tstate);
44688 if (PyErr_Occurred()) SWIG_fail;
44689 }
44690 resultobj = SWIG_Py_Void();
44691 return resultobj;
44692 fail:
44693 return NULL;
44694 }
44695
44696
44697 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44698 PyObject *resultobj = 0;
44699 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44700 unsigned int arg2 ;
44701 void *argp1 = 0 ;
44702 int res1 = 0 ;
44703 unsigned int val2 ;
44704 int ecode2 = 0 ;
44705 PyObject * obj0 = 0 ;
44706 PyObject * obj1 = 0 ;
44707 char * kwnames[] = {
44708 (char *) "self",(char *) "n", NULL
44709 };
44710
44711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44713 if (!SWIG_IsOK(res1)) {
44714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44715 }
44716 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44717 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44718 if (!SWIG_IsOK(ecode2)) {
44719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44720 }
44721 arg2 = static_cast< unsigned int >(val2);
44722 {
44723 PyThreadState* __tstate = wxPyBeginAllowThreads();
44724 (arg1)->Delete(arg2);
44725 wxPyEndAllowThreads(__tstate);
44726 if (PyErr_Occurred()) SWIG_fail;
44727 }
44728 resultobj = SWIG_Py_Void();
44729 return resultobj;
44730 fail:
44731 return NULL;
44732 }
44733
44734
44735 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44736 PyObject *resultobj = 0;
44737 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44738 unsigned int arg2 ;
44739 PyObject *result = 0 ;
44740 void *argp1 = 0 ;
44741 int res1 = 0 ;
44742 unsigned int val2 ;
44743 int ecode2 = 0 ;
44744 PyObject * obj0 = 0 ;
44745 PyObject * obj1 = 0 ;
44746 char * kwnames[] = {
44747 (char *) "self",(char *) "n", NULL
44748 };
44749
44750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44752 if (!SWIG_IsOK(res1)) {
44753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44754 }
44755 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44756 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44757 if (!SWIG_IsOK(ecode2)) {
44758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44759 }
44760 arg2 = static_cast< unsigned int >(val2);
44761 {
44762 PyThreadState* __tstate = wxPyBeginAllowThreads();
44763 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44764 wxPyEndAllowThreads(__tstate);
44765 if (PyErr_Occurred()) SWIG_fail;
44766 }
44767 resultobj = result;
44768 return resultobj;
44769 fail:
44770 return NULL;
44771 }
44772
44773
44774 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44775 PyObject *resultobj = 0;
44776 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44777 unsigned int arg2 ;
44778 PyObject *arg3 = (PyObject *) 0 ;
44779 void *argp1 = 0 ;
44780 int res1 = 0 ;
44781 unsigned int val2 ;
44782 int ecode2 = 0 ;
44783 PyObject * obj0 = 0 ;
44784 PyObject * obj1 = 0 ;
44785 PyObject * obj2 = 0 ;
44786 char * kwnames[] = {
44787 (char *) "self",(char *) "n",(char *) "clientData", NULL
44788 };
44789
44790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44792 if (!SWIG_IsOK(res1)) {
44793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44794 }
44795 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44796 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44797 if (!SWIG_IsOK(ecode2)) {
44798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44799 }
44800 arg2 = static_cast< unsigned int >(val2);
44801 arg3 = obj2;
44802 {
44803 PyThreadState* __tstate = wxPyBeginAllowThreads();
44804 wxItemContainer_SetClientData(arg1,arg2,arg3);
44805 wxPyEndAllowThreads(__tstate);
44806 if (PyErr_Occurred()) SWIG_fail;
44807 }
44808 resultobj = SWIG_Py_Void();
44809 return resultobj;
44810 fail:
44811 return NULL;
44812 }
44813
44814
44815 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44816 PyObject *resultobj = 0;
44817 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44818 unsigned int result;
44819 void *argp1 = 0 ;
44820 int res1 = 0 ;
44821 PyObject *swig_obj[1] ;
44822
44823 if (!args) SWIG_fail;
44824 swig_obj[0] = args;
44825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44826 if (!SWIG_IsOK(res1)) {
44827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44828 }
44829 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44833 wxPyEndAllowThreads(__tstate);
44834 if (PyErr_Occurred()) SWIG_fail;
44835 }
44836 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44837 return resultobj;
44838 fail:
44839 return NULL;
44840 }
44841
44842
44843 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44844 PyObject *resultobj = 0;
44845 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44846 bool result;
44847 void *argp1 = 0 ;
44848 int res1 = 0 ;
44849 PyObject *swig_obj[1] ;
44850
44851 if (!args) SWIG_fail;
44852 swig_obj[0] = args;
44853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44854 if (!SWIG_IsOK(res1)) {
44855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44856 }
44857 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44858 {
44859 PyThreadState* __tstate = wxPyBeginAllowThreads();
44860 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44861 wxPyEndAllowThreads(__tstate);
44862 if (PyErr_Occurred()) SWIG_fail;
44863 }
44864 {
44865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44866 }
44867 return resultobj;
44868 fail:
44869 return NULL;
44870 }
44871
44872
44873 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44874 PyObject *resultobj = 0;
44875 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44876 unsigned int arg2 ;
44877 wxString result;
44878 void *argp1 = 0 ;
44879 int res1 = 0 ;
44880 unsigned int val2 ;
44881 int ecode2 = 0 ;
44882 PyObject * obj0 = 0 ;
44883 PyObject * obj1 = 0 ;
44884 char * kwnames[] = {
44885 (char *) "self",(char *) "n", NULL
44886 };
44887
44888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44890 if (!SWIG_IsOK(res1)) {
44891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44892 }
44893 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44894 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44895 if (!SWIG_IsOK(ecode2)) {
44896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44897 }
44898 arg2 = static_cast< unsigned int >(val2);
44899 {
44900 PyThreadState* __tstate = wxPyBeginAllowThreads();
44901 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44902 wxPyEndAllowThreads(__tstate);
44903 if (PyErr_Occurred()) SWIG_fail;
44904 }
44905 {
44906 #if wxUSE_UNICODE
44907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44908 #else
44909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44910 #endif
44911 }
44912 return resultobj;
44913 fail:
44914 return NULL;
44915 }
44916
44917
44918 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44919 PyObject *resultobj = 0;
44920 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44921 wxArrayString result;
44922 void *argp1 = 0 ;
44923 int res1 = 0 ;
44924 PyObject *swig_obj[1] ;
44925
44926 if (!args) SWIG_fail;
44927 swig_obj[0] = args;
44928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44929 if (!SWIG_IsOK(res1)) {
44930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44931 }
44932 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44933 {
44934 PyThreadState* __tstate = wxPyBeginAllowThreads();
44935 result = ((wxItemContainer const *)arg1)->GetStrings();
44936 wxPyEndAllowThreads(__tstate);
44937 if (PyErr_Occurred()) SWIG_fail;
44938 }
44939 {
44940 resultobj = wxArrayString2PyList_helper(result);
44941 }
44942 return resultobj;
44943 fail:
44944 return NULL;
44945 }
44946
44947
44948 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44949 PyObject *resultobj = 0;
44950 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44951 unsigned int arg2 ;
44952 wxString *arg3 = 0 ;
44953 void *argp1 = 0 ;
44954 int res1 = 0 ;
44955 unsigned int val2 ;
44956 int ecode2 = 0 ;
44957 bool temp3 = false ;
44958 PyObject * obj0 = 0 ;
44959 PyObject * obj1 = 0 ;
44960 PyObject * obj2 = 0 ;
44961 char * kwnames[] = {
44962 (char *) "self",(char *) "n",(char *) "s", NULL
44963 };
44964
44965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44967 if (!SWIG_IsOK(res1)) {
44968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44969 }
44970 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44971 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44972 if (!SWIG_IsOK(ecode2)) {
44973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44974 }
44975 arg2 = static_cast< unsigned int >(val2);
44976 {
44977 arg3 = wxString_in_helper(obj2);
44978 if (arg3 == NULL) SWIG_fail;
44979 temp3 = true;
44980 }
44981 {
44982 PyThreadState* __tstate = wxPyBeginAllowThreads();
44983 (arg1)->SetString(arg2,(wxString const &)*arg3);
44984 wxPyEndAllowThreads(__tstate);
44985 if (PyErr_Occurred()) SWIG_fail;
44986 }
44987 resultobj = SWIG_Py_Void();
44988 {
44989 if (temp3)
44990 delete arg3;
44991 }
44992 return resultobj;
44993 fail:
44994 {
44995 if (temp3)
44996 delete arg3;
44997 }
44998 return NULL;
44999 }
45000
45001
45002 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45003 PyObject *resultobj = 0;
45004 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45005 wxString *arg2 = 0 ;
45006 int result;
45007 void *argp1 = 0 ;
45008 int res1 = 0 ;
45009 bool temp2 = false ;
45010 PyObject * obj0 = 0 ;
45011 PyObject * obj1 = 0 ;
45012 char * kwnames[] = {
45013 (char *) "self",(char *) "s", NULL
45014 };
45015
45016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45018 if (!SWIG_IsOK(res1)) {
45019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45020 }
45021 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45022 {
45023 arg2 = wxString_in_helper(obj1);
45024 if (arg2 == NULL) SWIG_fail;
45025 temp2 = true;
45026 }
45027 {
45028 PyThreadState* __tstate = wxPyBeginAllowThreads();
45029 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45030 wxPyEndAllowThreads(__tstate);
45031 if (PyErr_Occurred()) SWIG_fail;
45032 }
45033 resultobj = SWIG_From_int(static_cast< int >(result));
45034 {
45035 if (temp2)
45036 delete arg2;
45037 }
45038 return resultobj;
45039 fail:
45040 {
45041 if (temp2)
45042 delete arg2;
45043 }
45044 return NULL;
45045 }
45046
45047
45048 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45049 PyObject *resultobj = 0;
45050 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45051 int arg2 ;
45052 void *argp1 = 0 ;
45053 int res1 = 0 ;
45054 int val2 ;
45055 int ecode2 = 0 ;
45056 PyObject * obj0 = 0 ;
45057 PyObject * obj1 = 0 ;
45058 char * kwnames[] = {
45059 (char *) "self",(char *) "n", NULL
45060 };
45061
45062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45064 if (!SWIG_IsOK(res1)) {
45065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45066 }
45067 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45068 ecode2 = SWIG_AsVal_int(obj1, &val2);
45069 if (!SWIG_IsOK(ecode2)) {
45070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45071 }
45072 arg2 = static_cast< int >(val2);
45073 {
45074 PyThreadState* __tstate = wxPyBeginAllowThreads();
45075 (arg1)->SetSelection(arg2);
45076 wxPyEndAllowThreads(__tstate);
45077 if (PyErr_Occurred()) SWIG_fail;
45078 }
45079 resultobj = SWIG_Py_Void();
45080 return resultobj;
45081 fail:
45082 return NULL;
45083 }
45084
45085
45086 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45087 PyObject *resultobj = 0;
45088 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45089 int result;
45090 void *argp1 = 0 ;
45091 int res1 = 0 ;
45092 PyObject *swig_obj[1] ;
45093
45094 if (!args) SWIG_fail;
45095 swig_obj[0] = args;
45096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45097 if (!SWIG_IsOK(res1)) {
45098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45099 }
45100 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45101 {
45102 PyThreadState* __tstate = wxPyBeginAllowThreads();
45103 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45104 wxPyEndAllowThreads(__tstate);
45105 if (PyErr_Occurred()) SWIG_fail;
45106 }
45107 resultobj = SWIG_From_int(static_cast< int >(result));
45108 return resultobj;
45109 fail:
45110 return NULL;
45111 }
45112
45113
45114 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45115 PyObject *resultobj = 0;
45116 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45117 wxString *arg2 = 0 ;
45118 bool result;
45119 void *argp1 = 0 ;
45120 int res1 = 0 ;
45121 bool temp2 = false ;
45122 PyObject * obj0 = 0 ;
45123 PyObject * obj1 = 0 ;
45124 char * kwnames[] = {
45125 (char *) "self",(char *) "s", NULL
45126 };
45127
45128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45130 if (!SWIG_IsOK(res1)) {
45131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45132 }
45133 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45134 {
45135 arg2 = wxString_in_helper(obj1);
45136 if (arg2 == NULL) SWIG_fail;
45137 temp2 = true;
45138 }
45139 {
45140 PyThreadState* __tstate = wxPyBeginAllowThreads();
45141 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45142 wxPyEndAllowThreads(__tstate);
45143 if (PyErr_Occurred()) SWIG_fail;
45144 }
45145 {
45146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45147 }
45148 {
45149 if (temp2)
45150 delete arg2;
45151 }
45152 return resultobj;
45153 fail:
45154 {
45155 if (temp2)
45156 delete arg2;
45157 }
45158 return NULL;
45159 }
45160
45161
45162 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45163 PyObject *resultobj = 0;
45164 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45165 wxString result;
45166 void *argp1 = 0 ;
45167 int res1 = 0 ;
45168 PyObject *swig_obj[1] ;
45169
45170 if (!args) SWIG_fail;
45171 swig_obj[0] = args;
45172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45173 if (!SWIG_IsOK(res1)) {
45174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45175 }
45176 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45177 {
45178 PyThreadState* __tstate = wxPyBeginAllowThreads();
45179 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45180 wxPyEndAllowThreads(__tstate);
45181 if (PyErr_Occurred()) SWIG_fail;
45182 }
45183 {
45184 #if wxUSE_UNICODE
45185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45186 #else
45187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45188 #endif
45189 }
45190 return resultobj;
45191 fail:
45192 return NULL;
45193 }
45194
45195
45196 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45197 PyObject *resultobj = 0;
45198 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45199 int arg2 ;
45200 void *argp1 = 0 ;
45201 int res1 = 0 ;
45202 int val2 ;
45203 int ecode2 = 0 ;
45204 PyObject * obj0 = 0 ;
45205 PyObject * obj1 = 0 ;
45206 char * kwnames[] = {
45207 (char *) "self",(char *) "n", NULL
45208 };
45209
45210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45212 if (!SWIG_IsOK(res1)) {
45213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45214 }
45215 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45216 ecode2 = SWIG_AsVal_int(obj1, &val2);
45217 if (!SWIG_IsOK(ecode2)) {
45218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45219 }
45220 arg2 = static_cast< int >(val2);
45221 {
45222 PyThreadState* __tstate = wxPyBeginAllowThreads();
45223 (arg1)->Select(arg2);
45224 wxPyEndAllowThreads(__tstate);
45225 if (PyErr_Occurred()) SWIG_fail;
45226 }
45227 resultobj = SWIG_Py_Void();
45228 return resultobj;
45229 fail:
45230 return NULL;
45231 }
45232
45233
45234 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45235 PyObject *obj;
45236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45237 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45238 return SWIG_Py_Void();
45239 }
45240
45241 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45242 PyObject *obj;
45243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45244 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45245 return SWIG_Py_Void();
45246 }
45247
45248 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45249 PyObject *resultobj = 0;
45250 wxSizerItem *result = 0 ;
45251
45252 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45253 {
45254 PyThreadState* __tstate = wxPyBeginAllowThreads();
45255 result = (wxSizerItem *)new wxSizerItem();
45256 wxPyEndAllowThreads(__tstate);
45257 if (PyErr_Occurred()) SWIG_fail;
45258 }
45259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45260 return resultobj;
45261 fail:
45262 return NULL;
45263 }
45264
45265
45266 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45267 PyObject *resultobj = 0;
45268 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45269 void *argp1 = 0 ;
45270 int res1 = 0 ;
45271 PyObject *swig_obj[1] ;
45272
45273 if (!args) SWIG_fail;
45274 swig_obj[0] = args;
45275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45276 if (!SWIG_IsOK(res1)) {
45277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45278 }
45279 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45280 {
45281 PyThreadState* __tstate = wxPyBeginAllowThreads();
45282 delete arg1;
45283
45284 wxPyEndAllowThreads(__tstate);
45285 if (PyErr_Occurred()) SWIG_fail;
45286 }
45287 resultobj = SWIG_Py_Void();
45288 return resultobj;
45289 fail:
45290 return NULL;
45291 }
45292
45293
45294 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45295 PyObject *resultobj = 0;
45296 wxWindow *arg1 = (wxWindow *) 0 ;
45297 int arg2 ;
45298 int arg3 ;
45299 int arg4 ;
45300 PyObject *arg5 = (PyObject *) NULL ;
45301 wxSizerItem *result = 0 ;
45302 void *argp1 = 0 ;
45303 int res1 = 0 ;
45304 int val2 ;
45305 int ecode2 = 0 ;
45306 int val3 ;
45307 int ecode3 = 0 ;
45308 int val4 ;
45309 int ecode4 = 0 ;
45310 PyObject * obj0 = 0 ;
45311 PyObject * obj1 = 0 ;
45312 PyObject * obj2 = 0 ;
45313 PyObject * obj3 = 0 ;
45314 PyObject * obj4 = 0 ;
45315 char * kwnames[] = {
45316 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45317 };
45318
45319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45321 if (!SWIG_IsOK(res1)) {
45322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45323 }
45324 arg1 = reinterpret_cast< wxWindow * >(argp1);
45325 ecode2 = SWIG_AsVal_int(obj1, &val2);
45326 if (!SWIG_IsOK(ecode2)) {
45327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45328 }
45329 arg2 = static_cast< int >(val2);
45330 ecode3 = SWIG_AsVal_int(obj2, &val3);
45331 if (!SWIG_IsOK(ecode3)) {
45332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45333 }
45334 arg3 = static_cast< int >(val3);
45335 ecode4 = SWIG_AsVal_int(obj3, &val4);
45336 if (!SWIG_IsOK(ecode4)) {
45337 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45338 }
45339 arg4 = static_cast< int >(val4);
45340 if (obj4) {
45341 arg5 = obj4;
45342 }
45343 {
45344 PyThreadState* __tstate = wxPyBeginAllowThreads();
45345 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45346 wxPyEndAllowThreads(__tstate);
45347 if (PyErr_Occurred()) SWIG_fail;
45348 }
45349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45350 return resultobj;
45351 fail:
45352 return NULL;
45353 }
45354
45355
45356 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45357 PyObject *resultobj = 0;
45358 int arg1 ;
45359 int arg2 ;
45360 int arg3 ;
45361 int arg4 ;
45362 int arg5 ;
45363 PyObject *arg6 = (PyObject *) NULL ;
45364 wxSizerItem *result = 0 ;
45365 int val1 ;
45366 int ecode1 = 0 ;
45367 int val2 ;
45368 int ecode2 = 0 ;
45369 int val3 ;
45370 int ecode3 = 0 ;
45371 int val4 ;
45372 int ecode4 = 0 ;
45373 int val5 ;
45374 int ecode5 = 0 ;
45375 PyObject * obj0 = 0 ;
45376 PyObject * obj1 = 0 ;
45377 PyObject * obj2 = 0 ;
45378 PyObject * obj3 = 0 ;
45379 PyObject * obj4 = 0 ;
45380 PyObject * obj5 = 0 ;
45381 char * kwnames[] = {
45382 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45383 };
45384
45385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45386 ecode1 = SWIG_AsVal_int(obj0, &val1);
45387 if (!SWIG_IsOK(ecode1)) {
45388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45389 }
45390 arg1 = static_cast< int >(val1);
45391 ecode2 = SWIG_AsVal_int(obj1, &val2);
45392 if (!SWIG_IsOK(ecode2)) {
45393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45394 }
45395 arg2 = static_cast< int >(val2);
45396 ecode3 = SWIG_AsVal_int(obj2, &val3);
45397 if (!SWIG_IsOK(ecode3)) {
45398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45399 }
45400 arg3 = static_cast< int >(val3);
45401 ecode4 = SWIG_AsVal_int(obj3, &val4);
45402 if (!SWIG_IsOK(ecode4)) {
45403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45404 }
45405 arg4 = static_cast< int >(val4);
45406 ecode5 = SWIG_AsVal_int(obj4, &val5);
45407 if (!SWIG_IsOK(ecode5)) {
45408 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45409 }
45410 arg5 = static_cast< int >(val5);
45411 if (obj5) {
45412 arg6 = obj5;
45413 }
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45417 wxPyEndAllowThreads(__tstate);
45418 if (PyErr_Occurred()) SWIG_fail;
45419 }
45420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45421 return resultobj;
45422 fail:
45423 return NULL;
45424 }
45425
45426
45427 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45428 PyObject *resultobj = 0;
45429 wxSizer *arg1 = (wxSizer *) 0 ;
45430 int arg2 ;
45431 int arg3 ;
45432 int arg4 ;
45433 PyObject *arg5 = (PyObject *) NULL ;
45434 wxSizerItem *result = 0 ;
45435 int res1 = 0 ;
45436 int val2 ;
45437 int ecode2 = 0 ;
45438 int val3 ;
45439 int ecode3 = 0 ;
45440 int val4 ;
45441 int ecode4 = 0 ;
45442 PyObject * obj0 = 0 ;
45443 PyObject * obj1 = 0 ;
45444 PyObject * obj2 = 0 ;
45445 PyObject * obj3 = 0 ;
45446 PyObject * obj4 = 0 ;
45447 char * kwnames[] = {
45448 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45449 };
45450
45451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45452 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45453 if (!SWIG_IsOK(res1)) {
45454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45455 }
45456 ecode2 = SWIG_AsVal_int(obj1, &val2);
45457 if (!SWIG_IsOK(ecode2)) {
45458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45459 }
45460 arg2 = static_cast< int >(val2);
45461 ecode3 = SWIG_AsVal_int(obj2, &val3);
45462 if (!SWIG_IsOK(ecode3)) {
45463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45464 }
45465 arg3 = static_cast< int >(val3);
45466 ecode4 = SWIG_AsVal_int(obj3, &val4);
45467 if (!SWIG_IsOK(ecode4)) {
45468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45469 }
45470 arg4 = static_cast< int >(val4);
45471 if (obj4) {
45472 arg5 = obj4;
45473 }
45474 {
45475 PyThreadState* __tstate = wxPyBeginAllowThreads();
45476 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45477 wxPyEndAllowThreads(__tstate);
45478 if (PyErr_Occurred()) SWIG_fail;
45479 }
45480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45481 return resultobj;
45482 fail:
45483 return NULL;
45484 }
45485
45486
45487 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45488 PyObject *resultobj = 0;
45489 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45490 void *argp1 = 0 ;
45491 int res1 = 0 ;
45492 PyObject *swig_obj[1] ;
45493
45494 if (!args) SWIG_fail;
45495 swig_obj[0] = args;
45496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45497 if (!SWIG_IsOK(res1)) {
45498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45499 }
45500 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45501 {
45502 PyThreadState* __tstate = wxPyBeginAllowThreads();
45503 (arg1)->DeleteWindows();
45504 wxPyEndAllowThreads(__tstate);
45505 if (PyErr_Occurred()) SWIG_fail;
45506 }
45507 resultobj = SWIG_Py_Void();
45508 return resultobj;
45509 fail:
45510 return NULL;
45511 }
45512
45513
45514 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45515 PyObject *resultobj = 0;
45516 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45517 void *argp1 = 0 ;
45518 int res1 = 0 ;
45519 PyObject *swig_obj[1] ;
45520
45521 if (!args) SWIG_fail;
45522 swig_obj[0] = args;
45523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45524 if (!SWIG_IsOK(res1)) {
45525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45526 }
45527 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45528 {
45529 PyThreadState* __tstate = wxPyBeginAllowThreads();
45530 (arg1)->DetachSizer();
45531 wxPyEndAllowThreads(__tstate);
45532 if (PyErr_Occurred()) SWIG_fail;
45533 }
45534 resultobj = SWIG_Py_Void();
45535 return resultobj;
45536 fail:
45537 return NULL;
45538 }
45539
45540
45541 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45542 PyObject *resultobj = 0;
45543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45544 wxSize result;
45545 void *argp1 = 0 ;
45546 int res1 = 0 ;
45547 PyObject *swig_obj[1] ;
45548
45549 if (!args) SWIG_fail;
45550 swig_obj[0] = args;
45551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45552 if (!SWIG_IsOK(res1)) {
45553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45554 }
45555 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45556 {
45557 PyThreadState* __tstate = wxPyBeginAllowThreads();
45558 result = (arg1)->GetSize();
45559 wxPyEndAllowThreads(__tstate);
45560 if (PyErr_Occurred()) SWIG_fail;
45561 }
45562 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45563 return resultobj;
45564 fail:
45565 return NULL;
45566 }
45567
45568
45569 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45570 PyObject *resultobj = 0;
45571 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45572 wxSize result;
45573 void *argp1 = 0 ;
45574 int res1 = 0 ;
45575 PyObject *swig_obj[1] ;
45576
45577 if (!args) SWIG_fail;
45578 swig_obj[0] = args;
45579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45580 if (!SWIG_IsOK(res1)) {
45581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45582 }
45583 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45584 {
45585 PyThreadState* __tstate = wxPyBeginAllowThreads();
45586 result = (arg1)->CalcMin();
45587 wxPyEndAllowThreads(__tstate);
45588 if (PyErr_Occurred()) SWIG_fail;
45589 }
45590 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45591 return resultobj;
45592 fail:
45593 return NULL;
45594 }
45595
45596
45597 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45598 PyObject *resultobj = 0;
45599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45600 wxPoint *arg2 = 0 ;
45601 wxSize *arg3 = 0 ;
45602 void *argp1 = 0 ;
45603 int res1 = 0 ;
45604 wxPoint temp2 ;
45605 wxSize temp3 ;
45606 PyObject * obj0 = 0 ;
45607 PyObject * obj1 = 0 ;
45608 PyObject * obj2 = 0 ;
45609 char * kwnames[] = {
45610 (char *) "self",(char *) "pos",(char *) "size", NULL
45611 };
45612
45613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45615 if (!SWIG_IsOK(res1)) {
45616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45617 }
45618 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45619 {
45620 arg2 = &temp2;
45621 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45622 }
45623 {
45624 arg3 = &temp3;
45625 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45626 }
45627 {
45628 PyThreadState* __tstate = wxPyBeginAllowThreads();
45629 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
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_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45641 PyObject *resultobj = 0;
45642 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45643 wxSize result;
45644 void *argp1 = 0 ;
45645 int res1 = 0 ;
45646 PyObject *swig_obj[1] ;
45647
45648 if (!args) SWIG_fail;
45649 swig_obj[0] = args;
45650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45651 if (!SWIG_IsOK(res1)) {
45652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45653 }
45654 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45655 {
45656 PyThreadState* __tstate = wxPyBeginAllowThreads();
45657 result = (arg1)->GetMinSize();
45658 wxPyEndAllowThreads(__tstate);
45659 if (PyErr_Occurred()) SWIG_fail;
45660 }
45661 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45662 return resultobj;
45663 fail:
45664 return NULL;
45665 }
45666
45667
45668 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45669 PyObject *resultobj = 0;
45670 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45671 wxSize result;
45672 void *argp1 = 0 ;
45673 int res1 = 0 ;
45674 PyObject *swig_obj[1] ;
45675
45676 if (!args) SWIG_fail;
45677 swig_obj[0] = args;
45678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45679 if (!SWIG_IsOK(res1)) {
45680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45681 }
45682 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45683 {
45684 PyThreadState* __tstate = wxPyBeginAllowThreads();
45685 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45686 wxPyEndAllowThreads(__tstate);
45687 if (PyErr_Occurred()) SWIG_fail;
45688 }
45689 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45690 return resultobj;
45691 fail:
45692 return NULL;
45693 }
45694
45695
45696 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45697 PyObject *resultobj = 0;
45698 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45699 int arg2 ;
45700 int arg3 ;
45701 void *argp1 = 0 ;
45702 int res1 = 0 ;
45703 int val2 ;
45704 int ecode2 = 0 ;
45705 int val3 ;
45706 int ecode3 = 0 ;
45707 PyObject * obj0 = 0 ;
45708 PyObject * obj1 = 0 ;
45709 PyObject * obj2 = 0 ;
45710 char * kwnames[] = {
45711 (char *) "self",(char *) "x",(char *) "y", NULL
45712 };
45713
45714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45716 if (!SWIG_IsOK(res1)) {
45717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45718 }
45719 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45720 ecode2 = SWIG_AsVal_int(obj1, &val2);
45721 if (!SWIG_IsOK(ecode2)) {
45722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45723 }
45724 arg2 = static_cast< int >(val2);
45725 ecode3 = SWIG_AsVal_int(obj2, &val3);
45726 if (!SWIG_IsOK(ecode3)) {
45727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45728 }
45729 arg3 = static_cast< int >(val3);
45730 {
45731 PyThreadState* __tstate = wxPyBeginAllowThreads();
45732 (arg1)->SetInitSize(arg2,arg3);
45733 wxPyEndAllowThreads(__tstate);
45734 if (PyErr_Occurred()) SWIG_fail;
45735 }
45736 resultobj = SWIG_Py_Void();
45737 return resultobj;
45738 fail:
45739 return NULL;
45740 }
45741
45742
45743 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45744 PyObject *resultobj = 0;
45745 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45746 int arg2 ;
45747 int arg3 ;
45748 void *argp1 = 0 ;
45749 int res1 = 0 ;
45750 int val2 ;
45751 int ecode2 = 0 ;
45752 int val3 ;
45753 int ecode3 = 0 ;
45754 PyObject * obj0 = 0 ;
45755 PyObject * obj1 = 0 ;
45756 PyObject * obj2 = 0 ;
45757 char * kwnames[] = {
45758 (char *) "self",(char *) "width",(char *) "height", NULL
45759 };
45760
45761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45763 if (!SWIG_IsOK(res1)) {
45764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45765 }
45766 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45767 ecode2 = SWIG_AsVal_int(obj1, &val2);
45768 if (!SWIG_IsOK(ecode2)) {
45769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45770 }
45771 arg2 = static_cast< int >(val2);
45772 ecode3 = SWIG_AsVal_int(obj2, &val3);
45773 if (!SWIG_IsOK(ecode3)) {
45774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45775 }
45776 arg3 = static_cast< int >(val3);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 (arg1)->SetRatio(arg2,arg3);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 resultobj = SWIG_Py_Void();
45784 return resultobj;
45785 fail:
45786 return NULL;
45787 }
45788
45789
45790 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45791 PyObject *resultobj = 0;
45792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45793 wxSize *arg2 = 0 ;
45794 void *argp1 = 0 ;
45795 int res1 = 0 ;
45796 wxSize temp2 ;
45797 PyObject * obj0 = 0 ;
45798 PyObject * obj1 = 0 ;
45799 char * kwnames[] = {
45800 (char *) "self",(char *) "size", NULL
45801 };
45802
45803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45805 if (!SWIG_IsOK(res1)) {
45806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45807 }
45808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45809 {
45810 arg2 = &temp2;
45811 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45812 }
45813 {
45814 PyThreadState* __tstate = wxPyBeginAllowThreads();
45815 (arg1)->SetRatio((wxSize const &)*arg2);
45816 wxPyEndAllowThreads(__tstate);
45817 if (PyErr_Occurred()) SWIG_fail;
45818 }
45819 resultobj = SWIG_Py_Void();
45820 return resultobj;
45821 fail:
45822 return NULL;
45823 }
45824
45825
45826 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45827 PyObject *resultobj = 0;
45828 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45829 float arg2 ;
45830 void *argp1 = 0 ;
45831 int res1 = 0 ;
45832 float val2 ;
45833 int ecode2 = 0 ;
45834 PyObject * obj0 = 0 ;
45835 PyObject * obj1 = 0 ;
45836 char * kwnames[] = {
45837 (char *) "self",(char *) "ratio", NULL
45838 };
45839
45840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45842 if (!SWIG_IsOK(res1)) {
45843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45844 }
45845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45846 ecode2 = SWIG_AsVal_float(obj1, &val2);
45847 if (!SWIG_IsOK(ecode2)) {
45848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45849 }
45850 arg2 = static_cast< float >(val2);
45851 {
45852 PyThreadState* __tstate = wxPyBeginAllowThreads();
45853 (arg1)->SetRatio(arg2);
45854 wxPyEndAllowThreads(__tstate);
45855 if (PyErr_Occurred()) SWIG_fail;
45856 }
45857 resultobj = SWIG_Py_Void();
45858 return resultobj;
45859 fail:
45860 return NULL;
45861 }
45862
45863
45864 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45865 PyObject *resultobj = 0;
45866 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45867 float result;
45868 void *argp1 = 0 ;
45869 int res1 = 0 ;
45870 PyObject *swig_obj[1] ;
45871
45872 if (!args) SWIG_fail;
45873 swig_obj[0] = args;
45874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45875 if (!SWIG_IsOK(res1)) {
45876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45877 }
45878 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45879 {
45880 PyThreadState* __tstate = wxPyBeginAllowThreads();
45881 result = (float)(arg1)->GetRatio();
45882 wxPyEndAllowThreads(__tstate);
45883 if (PyErr_Occurred()) SWIG_fail;
45884 }
45885 resultobj = SWIG_From_float(static_cast< float >(result));
45886 return resultobj;
45887 fail:
45888 return NULL;
45889 }
45890
45891
45892 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45893 PyObject *resultobj = 0;
45894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45895 wxRect result;
45896 void *argp1 = 0 ;
45897 int res1 = 0 ;
45898 PyObject *swig_obj[1] ;
45899
45900 if (!args) SWIG_fail;
45901 swig_obj[0] = args;
45902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45903 if (!SWIG_IsOK(res1)) {
45904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45905 }
45906 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 result = (arg1)->GetRect();
45910 wxPyEndAllowThreads(__tstate);
45911 if (PyErr_Occurred()) SWIG_fail;
45912 }
45913 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45914 return resultobj;
45915 fail:
45916 return NULL;
45917 }
45918
45919
45920 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45921 PyObject *resultobj = 0;
45922 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45923 bool result;
45924 void *argp1 = 0 ;
45925 int res1 = 0 ;
45926 PyObject *swig_obj[1] ;
45927
45928 if (!args) SWIG_fail;
45929 swig_obj[0] = args;
45930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45931 if (!SWIG_IsOK(res1)) {
45932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45933 }
45934 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45935 {
45936 PyThreadState* __tstate = wxPyBeginAllowThreads();
45937 result = (bool)(arg1)->IsWindow();
45938 wxPyEndAllowThreads(__tstate);
45939 if (PyErr_Occurred()) SWIG_fail;
45940 }
45941 {
45942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45943 }
45944 return resultobj;
45945 fail:
45946 return NULL;
45947 }
45948
45949
45950 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45951 PyObject *resultobj = 0;
45952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45953 bool result;
45954 void *argp1 = 0 ;
45955 int res1 = 0 ;
45956 PyObject *swig_obj[1] ;
45957
45958 if (!args) SWIG_fail;
45959 swig_obj[0] = args;
45960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45961 if (!SWIG_IsOK(res1)) {
45962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45963 }
45964 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45965 {
45966 PyThreadState* __tstate = wxPyBeginAllowThreads();
45967 result = (bool)(arg1)->IsSizer();
45968 wxPyEndAllowThreads(__tstate);
45969 if (PyErr_Occurred()) SWIG_fail;
45970 }
45971 {
45972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45973 }
45974 return resultobj;
45975 fail:
45976 return NULL;
45977 }
45978
45979
45980 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45981 PyObject *resultobj = 0;
45982 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45983 bool result;
45984 void *argp1 = 0 ;
45985 int res1 = 0 ;
45986 PyObject *swig_obj[1] ;
45987
45988 if (!args) SWIG_fail;
45989 swig_obj[0] = args;
45990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45991 if (!SWIG_IsOK(res1)) {
45992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45993 }
45994 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45995 {
45996 PyThreadState* __tstate = wxPyBeginAllowThreads();
45997 result = (bool)(arg1)->IsSpacer();
45998 wxPyEndAllowThreads(__tstate);
45999 if (PyErr_Occurred()) SWIG_fail;
46000 }
46001 {
46002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46003 }
46004 return resultobj;
46005 fail:
46006 return NULL;
46007 }
46008
46009
46010 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46011 PyObject *resultobj = 0;
46012 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46013 int arg2 ;
46014 void *argp1 = 0 ;
46015 int res1 = 0 ;
46016 int val2 ;
46017 int ecode2 = 0 ;
46018 PyObject * obj0 = 0 ;
46019 PyObject * obj1 = 0 ;
46020 char * kwnames[] = {
46021 (char *) "self",(char *) "proportion", NULL
46022 };
46023
46024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46026 if (!SWIG_IsOK(res1)) {
46027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46028 }
46029 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46030 ecode2 = SWIG_AsVal_int(obj1, &val2);
46031 if (!SWIG_IsOK(ecode2)) {
46032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46033 }
46034 arg2 = static_cast< int >(val2);
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 (arg1)->SetProportion(arg2);
46038 wxPyEndAllowThreads(__tstate);
46039 if (PyErr_Occurred()) SWIG_fail;
46040 }
46041 resultobj = SWIG_Py_Void();
46042 return resultobj;
46043 fail:
46044 return NULL;
46045 }
46046
46047
46048 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46049 PyObject *resultobj = 0;
46050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46051 int result;
46052 void *argp1 = 0 ;
46053 int res1 = 0 ;
46054 PyObject *swig_obj[1] ;
46055
46056 if (!args) SWIG_fail;
46057 swig_obj[0] = args;
46058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46059 if (!SWIG_IsOK(res1)) {
46060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46061 }
46062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (int)(arg1)->GetProportion();
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 resultobj = SWIG_From_int(static_cast< int >(result));
46070 return resultobj;
46071 fail:
46072 return NULL;
46073 }
46074
46075
46076 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46077 PyObject *resultobj = 0;
46078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46079 int arg2 ;
46080 void *argp1 = 0 ;
46081 int res1 = 0 ;
46082 int val2 ;
46083 int ecode2 = 0 ;
46084 PyObject * obj0 = 0 ;
46085 PyObject * obj1 = 0 ;
46086 char * kwnames[] = {
46087 (char *) "self",(char *) "flag", NULL
46088 };
46089
46090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46092 if (!SWIG_IsOK(res1)) {
46093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46094 }
46095 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46096 ecode2 = SWIG_AsVal_int(obj1, &val2);
46097 if (!SWIG_IsOK(ecode2)) {
46098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46099 }
46100 arg2 = static_cast< int >(val2);
46101 {
46102 PyThreadState* __tstate = wxPyBeginAllowThreads();
46103 (arg1)->SetFlag(arg2);
46104 wxPyEndAllowThreads(__tstate);
46105 if (PyErr_Occurred()) SWIG_fail;
46106 }
46107 resultobj = SWIG_Py_Void();
46108 return resultobj;
46109 fail:
46110 return NULL;
46111 }
46112
46113
46114 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46115 PyObject *resultobj = 0;
46116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46117 int result;
46118 void *argp1 = 0 ;
46119 int res1 = 0 ;
46120 PyObject *swig_obj[1] ;
46121
46122 if (!args) SWIG_fail;
46123 swig_obj[0] = args;
46124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46125 if (!SWIG_IsOK(res1)) {
46126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46127 }
46128 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46129 {
46130 PyThreadState* __tstate = wxPyBeginAllowThreads();
46131 result = (int)(arg1)->GetFlag();
46132 wxPyEndAllowThreads(__tstate);
46133 if (PyErr_Occurred()) SWIG_fail;
46134 }
46135 resultobj = SWIG_From_int(static_cast< int >(result));
46136 return resultobj;
46137 fail:
46138 return NULL;
46139 }
46140
46141
46142 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46143 PyObject *resultobj = 0;
46144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46145 int arg2 ;
46146 void *argp1 = 0 ;
46147 int res1 = 0 ;
46148 int val2 ;
46149 int ecode2 = 0 ;
46150 PyObject * obj0 = 0 ;
46151 PyObject * obj1 = 0 ;
46152 char * kwnames[] = {
46153 (char *) "self",(char *) "border", NULL
46154 };
46155
46156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46158 if (!SWIG_IsOK(res1)) {
46159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46160 }
46161 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46162 ecode2 = SWIG_AsVal_int(obj1, &val2);
46163 if (!SWIG_IsOK(ecode2)) {
46164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46165 }
46166 arg2 = static_cast< int >(val2);
46167 {
46168 PyThreadState* __tstate = wxPyBeginAllowThreads();
46169 (arg1)->SetBorder(arg2);
46170 wxPyEndAllowThreads(__tstate);
46171 if (PyErr_Occurred()) SWIG_fail;
46172 }
46173 resultobj = SWIG_Py_Void();
46174 return resultobj;
46175 fail:
46176 return NULL;
46177 }
46178
46179
46180 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46181 PyObject *resultobj = 0;
46182 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46183 int result;
46184 void *argp1 = 0 ;
46185 int res1 = 0 ;
46186 PyObject *swig_obj[1] ;
46187
46188 if (!args) SWIG_fail;
46189 swig_obj[0] = args;
46190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46191 if (!SWIG_IsOK(res1)) {
46192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46193 }
46194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46195 {
46196 PyThreadState* __tstate = wxPyBeginAllowThreads();
46197 result = (int)(arg1)->GetBorder();
46198 wxPyEndAllowThreads(__tstate);
46199 if (PyErr_Occurred()) SWIG_fail;
46200 }
46201 resultobj = SWIG_From_int(static_cast< int >(result));
46202 return resultobj;
46203 fail:
46204 return NULL;
46205 }
46206
46207
46208 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46209 PyObject *resultobj = 0;
46210 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46211 wxWindow *result = 0 ;
46212 void *argp1 = 0 ;
46213 int res1 = 0 ;
46214 PyObject *swig_obj[1] ;
46215
46216 if (!args) SWIG_fail;
46217 swig_obj[0] = args;
46218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46219 if (!SWIG_IsOK(res1)) {
46220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46221 }
46222 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46223 {
46224 PyThreadState* __tstate = wxPyBeginAllowThreads();
46225 result = (wxWindow *)(arg1)->GetWindow();
46226 wxPyEndAllowThreads(__tstate);
46227 if (PyErr_Occurred()) SWIG_fail;
46228 }
46229 {
46230 resultobj = wxPyMake_wxObject(result, 0);
46231 }
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46239 PyObject *resultobj = 0;
46240 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46241 wxWindow *arg2 = (wxWindow *) 0 ;
46242 void *argp1 = 0 ;
46243 int res1 = 0 ;
46244 void *argp2 = 0 ;
46245 int res2 = 0 ;
46246 PyObject * obj0 = 0 ;
46247 PyObject * obj1 = 0 ;
46248 char * kwnames[] = {
46249 (char *) "self",(char *) "window", NULL
46250 };
46251
46252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46254 if (!SWIG_IsOK(res1)) {
46255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46256 }
46257 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46259 if (!SWIG_IsOK(res2)) {
46260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46261 }
46262 arg2 = reinterpret_cast< wxWindow * >(argp2);
46263 {
46264 PyThreadState* __tstate = wxPyBeginAllowThreads();
46265 (arg1)->SetWindow(arg2);
46266 wxPyEndAllowThreads(__tstate);
46267 if (PyErr_Occurred()) SWIG_fail;
46268 }
46269 resultobj = SWIG_Py_Void();
46270 return resultobj;
46271 fail:
46272 return NULL;
46273 }
46274
46275
46276 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46277 PyObject *resultobj = 0;
46278 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46279 wxSizer *result = 0 ;
46280 void *argp1 = 0 ;
46281 int res1 = 0 ;
46282 PyObject *swig_obj[1] ;
46283
46284 if (!args) SWIG_fail;
46285 swig_obj[0] = args;
46286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46287 if (!SWIG_IsOK(res1)) {
46288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46289 }
46290 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46291 {
46292 PyThreadState* __tstate = wxPyBeginAllowThreads();
46293 result = (wxSizer *)(arg1)->GetSizer();
46294 wxPyEndAllowThreads(__tstate);
46295 if (PyErr_Occurred()) SWIG_fail;
46296 }
46297 {
46298 resultobj = wxPyMake_wxObject(result, (bool)0);
46299 }
46300 return resultobj;
46301 fail:
46302 return NULL;
46303 }
46304
46305
46306 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46307 PyObject *resultobj = 0;
46308 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46309 wxSizer *arg2 = (wxSizer *) 0 ;
46310 void *argp1 = 0 ;
46311 int res1 = 0 ;
46312 int res2 = 0 ;
46313 PyObject * obj0 = 0 ;
46314 PyObject * obj1 = 0 ;
46315 char * kwnames[] = {
46316 (char *) "self",(char *) "sizer", NULL
46317 };
46318
46319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46321 if (!SWIG_IsOK(res1)) {
46322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46323 }
46324 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46325 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46326 if (!SWIG_IsOK(res2)) {
46327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46328 }
46329 {
46330 PyThreadState* __tstate = wxPyBeginAllowThreads();
46331 (arg1)->SetSizer(arg2);
46332 wxPyEndAllowThreads(__tstate);
46333 if (PyErr_Occurred()) SWIG_fail;
46334 }
46335 resultobj = SWIG_Py_Void();
46336 return resultobj;
46337 fail:
46338 return NULL;
46339 }
46340
46341
46342 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46343 PyObject *resultobj = 0;
46344 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46345 wxSize *result = 0 ;
46346 void *argp1 = 0 ;
46347 int res1 = 0 ;
46348 PyObject *swig_obj[1] ;
46349
46350 if (!args) SWIG_fail;
46351 swig_obj[0] = args;
46352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46353 if (!SWIG_IsOK(res1)) {
46354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46355 }
46356 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46357 {
46358 PyThreadState* __tstate = wxPyBeginAllowThreads();
46359 {
46360 wxSize const &_result_ref = (arg1)->GetSpacer();
46361 result = (wxSize *) &_result_ref;
46362 }
46363 wxPyEndAllowThreads(__tstate);
46364 if (PyErr_Occurred()) SWIG_fail;
46365 }
46366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46367 return resultobj;
46368 fail:
46369 return NULL;
46370 }
46371
46372
46373 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46374 PyObject *resultobj = 0;
46375 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46376 wxSize *arg2 = 0 ;
46377 void *argp1 = 0 ;
46378 int res1 = 0 ;
46379 wxSize temp2 ;
46380 PyObject * obj0 = 0 ;
46381 PyObject * obj1 = 0 ;
46382 char * kwnames[] = {
46383 (char *) "self",(char *) "size", NULL
46384 };
46385
46386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46388 if (!SWIG_IsOK(res1)) {
46389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46390 }
46391 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46392 {
46393 arg2 = &temp2;
46394 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46395 }
46396 {
46397 PyThreadState* __tstate = wxPyBeginAllowThreads();
46398 (arg1)->SetSpacer((wxSize const &)*arg2);
46399 wxPyEndAllowThreads(__tstate);
46400 if (PyErr_Occurred()) SWIG_fail;
46401 }
46402 resultobj = SWIG_Py_Void();
46403 return resultobj;
46404 fail:
46405 return NULL;
46406 }
46407
46408
46409 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46410 PyObject *resultobj = 0;
46411 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46412 bool arg2 ;
46413 void *argp1 = 0 ;
46414 int res1 = 0 ;
46415 bool val2 ;
46416 int ecode2 = 0 ;
46417 PyObject * obj0 = 0 ;
46418 PyObject * obj1 = 0 ;
46419 char * kwnames[] = {
46420 (char *) "self",(char *) "show", NULL
46421 };
46422
46423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46425 if (!SWIG_IsOK(res1)) {
46426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46427 }
46428 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46429 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46430 if (!SWIG_IsOK(ecode2)) {
46431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46432 }
46433 arg2 = static_cast< bool >(val2);
46434 {
46435 PyThreadState* __tstate = wxPyBeginAllowThreads();
46436 (arg1)->Show(arg2);
46437 wxPyEndAllowThreads(__tstate);
46438 if (PyErr_Occurred()) SWIG_fail;
46439 }
46440 resultobj = SWIG_Py_Void();
46441 return resultobj;
46442 fail:
46443 return NULL;
46444 }
46445
46446
46447 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46448 PyObject *resultobj = 0;
46449 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46450 bool result;
46451 void *argp1 = 0 ;
46452 int res1 = 0 ;
46453 PyObject *swig_obj[1] ;
46454
46455 if (!args) SWIG_fail;
46456 swig_obj[0] = args;
46457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46458 if (!SWIG_IsOK(res1)) {
46459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46460 }
46461 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46462 {
46463 PyThreadState* __tstate = wxPyBeginAllowThreads();
46464 result = (bool)(arg1)->IsShown();
46465 wxPyEndAllowThreads(__tstate);
46466 if (PyErr_Occurred()) SWIG_fail;
46467 }
46468 {
46469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46470 }
46471 return resultobj;
46472 fail:
46473 return NULL;
46474 }
46475
46476
46477 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46478 PyObject *resultobj = 0;
46479 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46480 wxPoint result;
46481 void *argp1 = 0 ;
46482 int res1 = 0 ;
46483 PyObject *swig_obj[1] ;
46484
46485 if (!args) SWIG_fail;
46486 swig_obj[0] = args;
46487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46488 if (!SWIG_IsOK(res1)) {
46489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46490 }
46491 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46492 {
46493 PyThreadState* __tstate = wxPyBeginAllowThreads();
46494 result = (arg1)->GetPosition();
46495 wxPyEndAllowThreads(__tstate);
46496 if (PyErr_Occurred()) SWIG_fail;
46497 }
46498 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46499 return resultobj;
46500 fail:
46501 return NULL;
46502 }
46503
46504
46505 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46506 PyObject *resultobj = 0;
46507 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46508 PyObject *result = 0 ;
46509 void *argp1 = 0 ;
46510 int res1 = 0 ;
46511 PyObject *swig_obj[1] ;
46512
46513 if (!args) SWIG_fail;
46514 swig_obj[0] = args;
46515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46516 if (!SWIG_IsOK(res1)) {
46517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46518 }
46519 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46520 {
46521 PyThreadState* __tstate = wxPyBeginAllowThreads();
46522 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46523 wxPyEndAllowThreads(__tstate);
46524 if (PyErr_Occurred()) SWIG_fail;
46525 }
46526 resultobj = result;
46527 return resultobj;
46528 fail:
46529 return NULL;
46530 }
46531
46532
46533 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46534 PyObject *resultobj = 0;
46535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46536 PyObject *arg2 = (PyObject *) 0 ;
46537 void *argp1 = 0 ;
46538 int res1 = 0 ;
46539 PyObject * obj0 = 0 ;
46540 PyObject * obj1 = 0 ;
46541 char * kwnames[] = {
46542 (char *) "self",(char *) "userData", NULL
46543 };
46544
46545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46547 if (!SWIG_IsOK(res1)) {
46548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46549 }
46550 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46551 arg2 = obj1;
46552 {
46553 PyThreadState* __tstate = wxPyBeginAllowThreads();
46554 wxSizerItem_SetUserData(arg1,arg2);
46555 wxPyEndAllowThreads(__tstate);
46556 if (PyErr_Occurred()) SWIG_fail;
46557 }
46558 resultobj = SWIG_Py_Void();
46559 return resultobj;
46560 fail:
46561 return NULL;
46562 }
46563
46564
46565 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46566 PyObject *obj;
46567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46568 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46569 return SWIG_Py_Void();
46570 }
46571
46572 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46573 return SWIG_Python_InitShadowInstance(args);
46574 }
46575
46576 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46577 PyObject *resultobj = 0;
46578 wxSizer *arg1 = (wxSizer *) 0 ;
46579 void *argp1 = 0 ;
46580 int res1 = 0 ;
46581 PyObject *swig_obj[1] ;
46582
46583 if (!args) SWIG_fail;
46584 swig_obj[0] = args;
46585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46586 if (!SWIG_IsOK(res1)) {
46587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46588 }
46589 arg1 = reinterpret_cast< wxSizer * >(argp1);
46590 {
46591 PyThreadState* __tstate = wxPyBeginAllowThreads();
46592 delete arg1;
46593
46594 wxPyEndAllowThreads(__tstate);
46595 if (PyErr_Occurred()) SWIG_fail;
46596 }
46597 resultobj = SWIG_Py_Void();
46598 return resultobj;
46599 fail:
46600 return NULL;
46601 }
46602
46603
46604 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46605 PyObject *resultobj = 0;
46606 wxSizer *arg1 = (wxSizer *) 0 ;
46607 PyObject *arg2 = (PyObject *) 0 ;
46608 void *argp1 = 0 ;
46609 int res1 = 0 ;
46610 PyObject * obj0 = 0 ;
46611 PyObject * obj1 = 0 ;
46612 char * kwnames[] = {
46613 (char *) "self",(char *) "_self", NULL
46614 };
46615
46616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46618 if (!SWIG_IsOK(res1)) {
46619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46620 }
46621 arg1 = reinterpret_cast< wxSizer * >(argp1);
46622 arg2 = obj1;
46623 {
46624 PyThreadState* __tstate = wxPyBeginAllowThreads();
46625 wxSizer__setOORInfo(arg1,arg2);
46626 wxPyEndAllowThreads(__tstate);
46627 if (PyErr_Occurred()) SWIG_fail;
46628 }
46629 resultobj = SWIG_Py_Void();
46630 return resultobj;
46631 fail:
46632 return NULL;
46633 }
46634
46635
46636 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46637 PyObject *resultobj = 0;
46638 wxSizer *arg1 = (wxSizer *) 0 ;
46639 PyObject *arg2 = (PyObject *) 0 ;
46640 int arg3 = (int) 0 ;
46641 int arg4 = (int) 0 ;
46642 int arg5 = (int) 0 ;
46643 PyObject *arg6 = (PyObject *) NULL ;
46644 wxSizerItem *result = 0 ;
46645 void *argp1 = 0 ;
46646 int res1 = 0 ;
46647 int val3 ;
46648 int ecode3 = 0 ;
46649 int val4 ;
46650 int ecode4 = 0 ;
46651 int val5 ;
46652 int ecode5 = 0 ;
46653 PyObject * obj0 = 0 ;
46654 PyObject * obj1 = 0 ;
46655 PyObject * obj2 = 0 ;
46656 PyObject * obj3 = 0 ;
46657 PyObject * obj4 = 0 ;
46658 PyObject * obj5 = 0 ;
46659 char * kwnames[] = {
46660 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46661 };
46662
46663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46665 if (!SWIG_IsOK(res1)) {
46666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46667 }
46668 arg1 = reinterpret_cast< wxSizer * >(argp1);
46669 arg2 = obj1;
46670 if (obj2) {
46671 ecode3 = SWIG_AsVal_int(obj2, &val3);
46672 if (!SWIG_IsOK(ecode3)) {
46673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46674 }
46675 arg3 = static_cast< int >(val3);
46676 }
46677 if (obj3) {
46678 ecode4 = SWIG_AsVal_int(obj3, &val4);
46679 if (!SWIG_IsOK(ecode4)) {
46680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46681 }
46682 arg4 = static_cast< int >(val4);
46683 }
46684 if (obj4) {
46685 ecode5 = SWIG_AsVal_int(obj4, &val5);
46686 if (!SWIG_IsOK(ecode5)) {
46687 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46688 }
46689 arg5 = static_cast< int >(val5);
46690 }
46691 if (obj5) {
46692 arg6 = obj5;
46693 }
46694 {
46695 PyThreadState* __tstate = wxPyBeginAllowThreads();
46696 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46697 wxPyEndAllowThreads(__tstate);
46698 if (PyErr_Occurred()) SWIG_fail;
46699 }
46700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46701 return resultobj;
46702 fail:
46703 return NULL;
46704 }
46705
46706
46707 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46708 PyObject *resultobj = 0;
46709 wxSizer *arg1 = (wxSizer *) 0 ;
46710 int arg2 ;
46711 PyObject *arg3 = (PyObject *) 0 ;
46712 int arg4 = (int) 0 ;
46713 int arg5 = (int) 0 ;
46714 int arg6 = (int) 0 ;
46715 PyObject *arg7 = (PyObject *) NULL ;
46716 wxSizerItem *result = 0 ;
46717 void *argp1 = 0 ;
46718 int res1 = 0 ;
46719 int val2 ;
46720 int ecode2 = 0 ;
46721 int val4 ;
46722 int ecode4 = 0 ;
46723 int val5 ;
46724 int ecode5 = 0 ;
46725 int val6 ;
46726 int ecode6 = 0 ;
46727 PyObject * obj0 = 0 ;
46728 PyObject * obj1 = 0 ;
46729 PyObject * obj2 = 0 ;
46730 PyObject * obj3 = 0 ;
46731 PyObject * obj4 = 0 ;
46732 PyObject * obj5 = 0 ;
46733 PyObject * obj6 = 0 ;
46734 char * kwnames[] = {
46735 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46736 };
46737
46738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46740 if (!SWIG_IsOK(res1)) {
46741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46742 }
46743 arg1 = reinterpret_cast< wxSizer * >(argp1);
46744 ecode2 = SWIG_AsVal_int(obj1, &val2);
46745 if (!SWIG_IsOK(ecode2)) {
46746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46747 }
46748 arg2 = static_cast< int >(val2);
46749 arg3 = obj2;
46750 if (obj3) {
46751 ecode4 = SWIG_AsVal_int(obj3, &val4);
46752 if (!SWIG_IsOK(ecode4)) {
46753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46754 }
46755 arg4 = static_cast< int >(val4);
46756 }
46757 if (obj4) {
46758 ecode5 = SWIG_AsVal_int(obj4, &val5);
46759 if (!SWIG_IsOK(ecode5)) {
46760 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46761 }
46762 arg5 = static_cast< int >(val5);
46763 }
46764 if (obj5) {
46765 ecode6 = SWIG_AsVal_int(obj5, &val6);
46766 if (!SWIG_IsOK(ecode6)) {
46767 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46768 }
46769 arg6 = static_cast< int >(val6);
46770 }
46771 if (obj6) {
46772 arg7 = obj6;
46773 }
46774 {
46775 PyThreadState* __tstate = wxPyBeginAllowThreads();
46776 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46777 wxPyEndAllowThreads(__tstate);
46778 if (PyErr_Occurred()) SWIG_fail;
46779 }
46780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46781 return resultobj;
46782 fail:
46783 return NULL;
46784 }
46785
46786
46787 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46788 PyObject *resultobj = 0;
46789 wxSizer *arg1 = (wxSizer *) 0 ;
46790 PyObject *arg2 = (PyObject *) 0 ;
46791 int arg3 = (int) 0 ;
46792 int arg4 = (int) 0 ;
46793 int arg5 = (int) 0 ;
46794 PyObject *arg6 = (PyObject *) NULL ;
46795 wxSizerItem *result = 0 ;
46796 void *argp1 = 0 ;
46797 int res1 = 0 ;
46798 int val3 ;
46799 int ecode3 = 0 ;
46800 int val4 ;
46801 int ecode4 = 0 ;
46802 int val5 ;
46803 int ecode5 = 0 ;
46804 PyObject * obj0 = 0 ;
46805 PyObject * obj1 = 0 ;
46806 PyObject * obj2 = 0 ;
46807 PyObject * obj3 = 0 ;
46808 PyObject * obj4 = 0 ;
46809 PyObject * obj5 = 0 ;
46810 char * kwnames[] = {
46811 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46812 };
46813
46814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46816 if (!SWIG_IsOK(res1)) {
46817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46818 }
46819 arg1 = reinterpret_cast< wxSizer * >(argp1);
46820 arg2 = obj1;
46821 if (obj2) {
46822 ecode3 = SWIG_AsVal_int(obj2, &val3);
46823 if (!SWIG_IsOK(ecode3)) {
46824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46825 }
46826 arg3 = static_cast< int >(val3);
46827 }
46828 if (obj3) {
46829 ecode4 = SWIG_AsVal_int(obj3, &val4);
46830 if (!SWIG_IsOK(ecode4)) {
46831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46832 }
46833 arg4 = static_cast< int >(val4);
46834 }
46835 if (obj4) {
46836 ecode5 = SWIG_AsVal_int(obj4, &val5);
46837 if (!SWIG_IsOK(ecode5)) {
46838 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46839 }
46840 arg5 = static_cast< int >(val5);
46841 }
46842 if (obj5) {
46843 arg6 = obj5;
46844 }
46845 {
46846 PyThreadState* __tstate = wxPyBeginAllowThreads();
46847 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46848 wxPyEndAllowThreads(__tstate);
46849 if (PyErr_Occurred()) SWIG_fail;
46850 }
46851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46852 return resultobj;
46853 fail:
46854 return NULL;
46855 }
46856
46857
46858 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46859 PyObject *resultobj = 0;
46860 wxSizer *arg1 = (wxSizer *) 0 ;
46861 PyObject *arg2 = (PyObject *) 0 ;
46862 bool result;
46863 void *argp1 = 0 ;
46864 int res1 = 0 ;
46865 PyObject * obj0 = 0 ;
46866 PyObject * obj1 = 0 ;
46867 char * kwnames[] = {
46868 (char *) "self",(char *) "item", NULL
46869 };
46870
46871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46873 if (!SWIG_IsOK(res1)) {
46874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46875 }
46876 arg1 = reinterpret_cast< wxSizer * >(argp1);
46877 arg2 = obj1;
46878 {
46879 PyThreadState* __tstate = wxPyBeginAllowThreads();
46880 result = (bool)wxSizer_Remove(arg1,arg2);
46881 wxPyEndAllowThreads(__tstate);
46882 if (PyErr_Occurred()) SWIG_fail;
46883 }
46884 {
46885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46886 }
46887 return resultobj;
46888 fail:
46889 return NULL;
46890 }
46891
46892
46893 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46894 PyObject *resultobj = 0;
46895 wxSizer *arg1 = (wxSizer *) 0 ;
46896 PyObject *arg2 = (PyObject *) 0 ;
46897 bool result;
46898 void *argp1 = 0 ;
46899 int res1 = 0 ;
46900 PyObject * obj0 = 0 ;
46901 PyObject * obj1 = 0 ;
46902 char * kwnames[] = {
46903 (char *) "self",(char *) "item", NULL
46904 };
46905
46906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46908 if (!SWIG_IsOK(res1)) {
46909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46910 }
46911 arg1 = reinterpret_cast< wxSizer * >(argp1);
46912 arg2 = obj1;
46913 {
46914 PyThreadState* __tstate = wxPyBeginAllowThreads();
46915 result = (bool)wxSizer_Detach(arg1,arg2);
46916 wxPyEndAllowThreads(__tstate);
46917 if (PyErr_Occurred()) SWIG_fail;
46918 }
46919 {
46920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46921 }
46922 return resultobj;
46923 fail:
46924 return NULL;
46925 }
46926
46927
46928 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46929 PyObject *resultobj = 0;
46930 wxSizer *arg1 = (wxSizer *) 0 ;
46931 PyObject *arg2 = (PyObject *) 0 ;
46932 wxSizerItem *result = 0 ;
46933 void *argp1 = 0 ;
46934 int res1 = 0 ;
46935 PyObject * obj0 = 0 ;
46936 PyObject * obj1 = 0 ;
46937 char * kwnames[] = {
46938 (char *) "self",(char *) "item", NULL
46939 };
46940
46941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46943 if (!SWIG_IsOK(res1)) {
46944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46945 }
46946 arg1 = reinterpret_cast< wxSizer * >(argp1);
46947 arg2 = obj1;
46948 {
46949 PyThreadState* __tstate = wxPyBeginAllowThreads();
46950 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46951 wxPyEndAllowThreads(__tstate);
46952 if (PyErr_Occurred()) SWIG_fail;
46953 }
46954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46955 return resultobj;
46956 fail:
46957 return NULL;
46958 }
46959
46960
46961 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46962 PyObject *resultobj = 0;
46963 wxSizer *arg1 = (wxSizer *) 0 ;
46964 PyObject *arg2 = (PyObject *) 0 ;
46965 wxSize *arg3 = 0 ;
46966 void *argp1 = 0 ;
46967 int res1 = 0 ;
46968 wxSize temp3 ;
46969 PyObject * obj0 = 0 ;
46970 PyObject * obj1 = 0 ;
46971 PyObject * obj2 = 0 ;
46972 char * kwnames[] = {
46973 (char *) "self",(char *) "item",(char *) "size", NULL
46974 };
46975
46976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46978 if (!SWIG_IsOK(res1)) {
46979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46980 }
46981 arg1 = reinterpret_cast< wxSizer * >(argp1);
46982 arg2 = obj1;
46983 {
46984 arg3 = &temp3;
46985 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46986 }
46987 {
46988 PyThreadState* __tstate = wxPyBeginAllowThreads();
46989 wxSizer__SetItemMinSize(arg1,arg2,(wxSize 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_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47001 PyObject *resultobj = 0;
47002 wxSizer *arg1 = (wxSizer *) 0 ;
47003 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47004 wxSizerItem *result = 0 ;
47005 void *argp1 = 0 ;
47006 int res1 = 0 ;
47007 int res2 = 0 ;
47008 PyObject * obj0 = 0 ;
47009 PyObject * obj1 = 0 ;
47010 char * kwnames[] = {
47011 (char *) "self",(char *) "item", NULL
47012 };
47013
47014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47016 if (!SWIG_IsOK(res1)) {
47017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47018 }
47019 arg1 = reinterpret_cast< wxSizer * >(argp1);
47020 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47021 if (!SWIG_IsOK(res2)) {
47022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47023 }
47024 {
47025 PyThreadState* __tstate = wxPyBeginAllowThreads();
47026 result = (wxSizerItem *)(arg1)->Add(arg2);
47027 wxPyEndAllowThreads(__tstate);
47028 if (PyErr_Occurred()) SWIG_fail;
47029 }
47030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47031 return resultobj;
47032 fail:
47033 return NULL;
47034 }
47035
47036
47037 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47038 PyObject *resultobj = 0;
47039 wxSizer *arg1 = (wxSizer *) 0 ;
47040 size_t arg2 ;
47041 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47042 wxSizerItem *result = 0 ;
47043 void *argp1 = 0 ;
47044 int res1 = 0 ;
47045 size_t val2 ;
47046 int ecode2 = 0 ;
47047 int res3 = 0 ;
47048 PyObject * obj0 = 0 ;
47049 PyObject * obj1 = 0 ;
47050 PyObject * obj2 = 0 ;
47051 char * kwnames[] = {
47052 (char *) "self",(char *) "index",(char *) "item", NULL
47053 };
47054
47055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47057 if (!SWIG_IsOK(res1)) {
47058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47059 }
47060 arg1 = reinterpret_cast< wxSizer * >(argp1);
47061 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47062 if (!SWIG_IsOK(ecode2)) {
47063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47064 }
47065 arg2 = static_cast< size_t >(val2);
47066 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47067 if (!SWIG_IsOK(res3)) {
47068 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47069 }
47070 {
47071 PyThreadState* __tstate = wxPyBeginAllowThreads();
47072 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47073 wxPyEndAllowThreads(__tstate);
47074 if (PyErr_Occurred()) SWIG_fail;
47075 }
47076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47077 return resultobj;
47078 fail:
47079 return NULL;
47080 }
47081
47082
47083 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47084 PyObject *resultobj = 0;
47085 wxSizer *arg1 = (wxSizer *) 0 ;
47086 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47087 wxSizerItem *result = 0 ;
47088 void *argp1 = 0 ;
47089 int res1 = 0 ;
47090 int res2 = 0 ;
47091 PyObject * obj0 = 0 ;
47092 PyObject * obj1 = 0 ;
47093 char * kwnames[] = {
47094 (char *) "self",(char *) "item", NULL
47095 };
47096
47097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47099 if (!SWIG_IsOK(res1)) {
47100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47101 }
47102 arg1 = reinterpret_cast< wxSizer * >(argp1);
47103 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47104 if (!SWIG_IsOK(res2)) {
47105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47106 }
47107 {
47108 PyThreadState* __tstate = wxPyBeginAllowThreads();
47109 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47110 wxPyEndAllowThreads(__tstate);
47111 if (PyErr_Occurred()) SWIG_fail;
47112 }
47113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47114 return resultobj;
47115 fail:
47116 return NULL;
47117 }
47118
47119
47120 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47121 PyObject *resultobj = 0;
47122 wxSizer *arg1 = (wxSizer *) 0 ;
47123 int arg2 ;
47124 int arg3 ;
47125 int arg4 ;
47126 int arg5 ;
47127 void *argp1 = 0 ;
47128 int res1 = 0 ;
47129 int val2 ;
47130 int ecode2 = 0 ;
47131 int val3 ;
47132 int ecode3 = 0 ;
47133 int val4 ;
47134 int ecode4 = 0 ;
47135 int val5 ;
47136 int ecode5 = 0 ;
47137 PyObject * obj0 = 0 ;
47138 PyObject * obj1 = 0 ;
47139 PyObject * obj2 = 0 ;
47140 PyObject * obj3 = 0 ;
47141 PyObject * obj4 = 0 ;
47142 char * kwnames[] = {
47143 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47144 };
47145
47146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47148 if (!SWIG_IsOK(res1)) {
47149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47150 }
47151 arg1 = reinterpret_cast< wxSizer * >(argp1);
47152 ecode2 = SWIG_AsVal_int(obj1, &val2);
47153 if (!SWIG_IsOK(ecode2)) {
47154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47155 }
47156 arg2 = static_cast< int >(val2);
47157 ecode3 = SWIG_AsVal_int(obj2, &val3);
47158 if (!SWIG_IsOK(ecode3)) {
47159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47160 }
47161 arg3 = static_cast< int >(val3);
47162 ecode4 = SWIG_AsVal_int(obj3, &val4);
47163 if (!SWIG_IsOK(ecode4)) {
47164 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47165 }
47166 arg4 = static_cast< int >(val4);
47167 ecode5 = SWIG_AsVal_int(obj4, &val5);
47168 if (!SWIG_IsOK(ecode5)) {
47169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47170 }
47171 arg5 = static_cast< int >(val5);
47172 {
47173 PyThreadState* __tstate = wxPyBeginAllowThreads();
47174 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47175 wxPyEndAllowThreads(__tstate);
47176 if (PyErr_Occurred()) SWIG_fail;
47177 }
47178 resultobj = SWIG_Py_Void();
47179 return resultobj;
47180 fail:
47181 return NULL;
47182 }
47183
47184
47185 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47186 PyObject *resultobj = 0;
47187 wxSizer *arg1 = (wxSizer *) 0 ;
47188 wxSize *arg2 = 0 ;
47189 void *argp1 = 0 ;
47190 int res1 = 0 ;
47191 wxSize temp2 ;
47192 PyObject * obj0 = 0 ;
47193 PyObject * obj1 = 0 ;
47194 char * kwnames[] = {
47195 (char *) "self",(char *) "size", NULL
47196 };
47197
47198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47200 if (!SWIG_IsOK(res1)) {
47201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47202 }
47203 arg1 = reinterpret_cast< wxSizer * >(argp1);
47204 {
47205 arg2 = &temp2;
47206 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47207 }
47208 {
47209 PyThreadState* __tstate = wxPyBeginAllowThreads();
47210 (arg1)->SetMinSize((wxSize const &)*arg2);
47211 wxPyEndAllowThreads(__tstate);
47212 if (PyErr_Occurred()) SWIG_fail;
47213 }
47214 resultobj = SWIG_Py_Void();
47215 return resultobj;
47216 fail:
47217 return NULL;
47218 }
47219
47220
47221 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47222 PyObject *resultobj = 0;
47223 wxSizer *arg1 = (wxSizer *) 0 ;
47224 wxSize result;
47225 void *argp1 = 0 ;
47226 int res1 = 0 ;
47227 PyObject *swig_obj[1] ;
47228
47229 if (!args) SWIG_fail;
47230 swig_obj[0] = args;
47231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47232 if (!SWIG_IsOK(res1)) {
47233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47234 }
47235 arg1 = reinterpret_cast< wxSizer * >(argp1);
47236 {
47237 PyThreadState* __tstate = wxPyBeginAllowThreads();
47238 result = (arg1)->GetSize();
47239 wxPyEndAllowThreads(__tstate);
47240 if (PyErr_Occurred()) SWIG_fail;
47241 }
47242 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47243 return resultobj;
47244 fail:
47245 return NULL;
47246 }
47247
47248
47249 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47250 PyObject *resultobj = 0;
47251 wxSizer *arg1 = (wxSizer *) 0 ;
47252 wxPoint result;
47253 void *argp1 = 0 ;
47254 int res1 = 0 ;
47255 PyObject *swig_obj[1] ;
47256
47257 if (!args) SWIG_fail;
47258 swig_obj[0] = args;
47259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47260 if (!SWIG_IsOK(res1)) {
47261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47262 }
47263 arg1 = reinterpret_cast< wxSizer * >(argp1);
47264 {
47265 PyThreadState* __tstate = wxPyBeginAllowThreads();
47266 result = (arg1)->GetPosition();
47267 wxPyEndAllowThreads(__tstate);
47268 if (PyErr_Occurred()) SWIG_fail;
47269 }
47270 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47271 return resultobj;
47272 fail:
47273 return NULL;
47274 }
47275
47276
47277 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47278 PyObject *resultobj = 0;
47279 wxSizer *arg1 = (wxSizer *) 0 ;
47280 wxSize result;
47281 void *argp1 = 0 ;
47282 int res1 = 0 ;
47283 PyObject *swig_obj[1] ;
47284
47285 if (!args) SWIG_fail;
47286 swig_obj[0] = args;
47287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47288 if (!SWIG_IsOK(res1)) {
47289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47290 }
47291 arg1 = reinterpret_cast< wxSizer * >(argp1);
47292 {
47293 PyThreadState* __tstate = wxPyBeginAllowThreads();
47294 result = (arg1)->GetMinSize();
47295 wxPyEndAllowThreads(__tstate);
47296 if (PyErr_Occurred()) SWIG_fail;
47297 }
47298 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47299 return resultobj;
47300 fail:
47301 return NULL;
47302 }
47303
47304
47305 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47306 PyObject *resultobj = 0;
47307 wxSizer *arg1 = (wxSizer *) 0 ;
47308 void *argp1 = 0 ;
47309 int res1 = 0 ;
47310 PyObject *swig_obj[1] ;
47311
47312 if (!args) SWIG_fail;
47313 swig_obj[0] = args;
47314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47315 if (!SWIG_IsOK(res1)) {
47316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47317 }
47318 arg1 = reinterpret_cast< wxSizer * >(argp1);
47319 {
47320 PyThreadState* __tstate = wxPyBeginAllowThreads();
47321 (arg1)->RecalcSizes();
47322 wxPyEndAllowThreads(__tstate);
47323 if (PyErr_Occurred()) SWIG_fail;
47324 }
47325 resultobj = SWIG_Py_Void();
47326 return resultobj;
47327 fail:
47328 return NULL;
47329 }
47330
47331
47332 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47333 PyObject *resultobj = 0;
47334 wxSizer *arg1 = (wxSizer *) 0 ;
47335 wxSize result;
47336 void *argp1 = 0 ;
47337 int res1 = 0 ;
47338 PyObject *swig_obj[1] ;
47339
47340 if (!args) SWIG_fail;
47341 swig_obj[0] = args;
47342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47343 if (!SWIG_IsOK(res1)) {
47344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47345 }
47346 arg1 = reinterpret_cast< wxSizer * >(argp1);
47347 {
47348 PyThreadState* __tstate = wxPyBeginAllowThreads();
47349 result = (arg1)->CalcMin();
47350 wxPyEndAllowThreads(__tstate);
47351 if (PyErr_Occurred()) SWIG_fail;
47352 }
47353 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47354 return resultobj;
47355 fail:
47356 return NULL;
47357 }
47358
47359
47360 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47361 PyObject *resultobj = 0;
47362 wxSizer *arg1 = (wxSizer *) 0 ;
47363 void *argp1 = 0 ;
47364 int res1 = 0 ;
47365 PyObject *swig_obj[1] ;
47366
47367 if (!args) SWIG_fail;
47368 swig_obj[0] = args;
47369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47370 if (!SWIG_IsOK(res1)) {
47371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47372 }
47373 arg1 = reinterpret_cast< wxSizer * >(argp1);
47374 {
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 (arg1)->Layout();
47377 wxPyEndAllowThreads(__tstate);
47378 if (PyErr_Occurred()) SWIG_fail;
47379 }
47380 resultobj = SWIG_Py_Void();
47381 return resultobj;
47382 fail:
47383 return NULL;
47384 }
47385
47386
47387 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47388 PyObject *resultobj = 0;
47389 wxSizer *arg1 = (wxSizer *) 0 ;
47390 wxWindow *arg2 = (wxWindow *) 0 ;
47391 wxSize result;
47392 void *argp1 = 0 ;
47393 int res1 = 0 ;
47394 void *argp2 = 0 ;
47395 int res2 = 0 ;
47396 PyObject * obj0 = 0 ;
47397 PyObject * obj1 = 0 ;
47398 char * kwnames[] = {
47399 (char *) "self",(char *) "window", NULL
47400 };
47401
47402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47404 if (!SWIG_IsOK(res1)) {
47405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47406 }
47407 arg1 = reinterpret_cast< wxSizer * >(argp1);
47408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47409 if (!SWIG_IsOK(res2)) {
47410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47411 }
47412 arg2 = reinterpret_cast< wxWindow * >(argp2);
47413 {
47414 PyThreadState* __tstate = wxPyBeginAllowThreads();
47415 result = (arg1)->Fit(arg2);
47416 wxPyEndAllowThreads(__tstate);
47417 if (PyErr_Occurred()) SWIG_fail;
47418 }
47419 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47420 return resultobj;
47421 fail:
47422 return NULL;
47423 }
47424
47425
47426 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47427 PyObject *resultobj = 0;
47428 wxSizer *arg1 = (wxSizer *) 0 ;
47429 wxWindow *arg2 = (wxWindow *) 0 ;
47430 void *argp1 = 0 ;
47431 int res1 = 0 ;
47432 void *argp2 = 0 ;
47433 int res2 = 0 ;
47434 PyObject * obj0 = 0 ;
47435 PyObject * obj1 = 0 ;
47436 char * kwnames[] = {
47437 (char *) "self",(char *) "window", NULL
47438 };
47439
47440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47442 if (!SWIG_IsOK(res1)) {
47443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47444 }
47445 arg1 = reinterpret_cast< wxSizer * >(argp1);
47446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47447 if (!SWIG_IsOK(res2)) {
47448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47449 }
47450 arg2 = reinterpret_cast< wxWindow * >(argp2);
47451 {
47452 PyThreadState* __tstate = wxPyBeginAllowThreads();
47453 (arg1)->FitInside(arg2);
47454 wxPyEndAllowThreads(__tstate);
47455 if (PyErr_Occurred()) SWIG_fail;
47456 }
47457 resultobj = SWIG_Py_Void();
47458 return resultobj;
47459 fail:
47460 return NULL;
47461 }
47462
47463
47464 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47465 PyObject *resultobj = 0;
47466 wxSizer *arg1 = (wxSizer *) 0 ;
47467 wxWindow *arg2 = (wxWindow *) 0 ;
47468 void *argp1 = 0 ;
47469 int res1 = 0 ;
47470 void *argp2 = 0 ;
47471 int res2 = 0 ;
47472 PyObject * obj0 = 0 ;
47473 PyObject * obj1 = 0 ;
47474 char * kwnames[] = {
47475 (char *) "self",(char *) "window", NULL
47476 };
47477
47478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47480 if (!SWIG_IsOK(res1)) {
47481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47482 }
47483 arg1 = reinterpret_cast< wxSizer * >(argp1);
47484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47485 if (!SWIG_IsOK(res2)) {
47486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47487 }
47488 arg2 = reinterpret_cast< wxWindow * >(argp2);
47489 {
47490 PyThreadState* __tstate = wxPyBeginAllowThreads();
47491 (arg1)->SetSizeHints(arg2);
47492 wxPyEndAllowThreads(__tstate);
47493 if (PyErr_Occurred()) SWIG_fail;
47494 }
47495 resultobj = SWIG_Py_Void();
47496 return resultobj;
47497 fail:
47498 return NULL;
47499 }
47500
47501
47502 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47503 PyObject *resultobj = 0;
47504 wxSizer *arg1 = (wxSizer *) 0 ;
47505 wxWindow *arg2 = (wxWindow *) 0 ;
47506 void *argp1 = 0 ;
47507 int res1 = 0 ;
47508 void *argp2 = 0 ;
47509 int res2 = 0 ;
47510 PyObject * obj0 = 0 ;
47511 PyObject * obj1 = 0 ;
47512 char * kwnames[] = {
47513 (char *) "self",(char *) "window", NULL
47514 };
47515
47516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47518 if (!SWIG_IsOK(res1)) {
47519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47520 }
47521 arg1 = reinterpret_cast< wxSizer * >(argp1);
47522 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47523 if (!SWIG_IsOK(res2)) {
47524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47525 }
47526 arg2 = reinterpret_cast< wxWindow * >(argp2);
47527 {
47528 PyThreadState* __tstate = wxPyBeginAllowThreads();
47529 (arg1)->SetVirtualSizeHints(arg2);
47530 wxPyEndAllowThreads(__tstate);
47531 if (PyErr_Occurred()) SWIG_fail;
47532 }
47533 resultobj = SWIG_Py_Void();
47534 return resultobj;
47535 fail:
47536 return NULL;
47537 }
47538
47539
47540 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47541 PyObject *resultobj = 0;
47542 wxSizer *arg1 = (wxSizer *) 0 ;
47543 bool arg2 = (bool) false ;
47544 void *argp1 = 0 ;
47545 int res1 = 0 ;
47546 bool val2 ;
47547 int ecode2 = 0 ;
47548 PyObject * obj0 = 0 ;
47549 PyObject * obj1 = 0 ;
47550 char * kwnames[] = {
47551 (char *) "self",(char *) "deleteWindows", NULL
47552 };
47553
47554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47556 if (!SWIG_IsOK(res1)) {
47557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47558 }
47559 arg1 = reinterpret_cast< wxSizer * >(argp1);
47560 if (obj1) {
47561 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47562 if (!SWIG_IsOK(ecode2)) {
47563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47564 }
47565 arg2 = static_cast< bool >(val2);
47566 }
47567 {
47568 PyThreadState* __tstate = wxPyBeginAllowThreads();
47569 (arg1)->Clear(arg2);
47570 wxPyEndAllowThreads(__tstate);
47571 if (PyErr_Occurred()) SWIG_fail;
47572 }
47573 resultobj = SWIG_Py_Void();
47574 return resultobj;
47575 fail:
47576 return NULL;
47577 }
47578
47579
47580 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47581 PyObject *resultobj = 0;
47582 wxSizer *arg1 = (wxSizer *) 0 ;
47583 void *argp1 = 0 ;
47584 int res1 = 0 ;
47585 PyObject *swig_obj[1] ;
47586
47587 if (!args) SWIG_fail;
47588 swig_obj[0] = args;
47589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47590 if (!SWIG_IsOK(res1)) {
47591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47592 }
47593 arg1 = reinterpret_cast< wxSizer * >(argp1);
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 (arg1)->DeleteWindows();
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_Py_Void();
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 PyObject *resultobj = 0;
47609 wxSizer *arg1 = (wxSizer *) 0 ;
47610 PyObject *result = 0 ;
47611 void *argp1 = 0 ;
47612 int res1 = 0 ;
47613 PyObject *swig_obj[1] ;
47614
47615 if (!args) SWIG_fail;
47616 swig_obj[0] = args;
47617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47618 if (!SWIG_IsOK(res1)) {
47619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47620 }
47621 arg1 = reinterpret_cast< wxSizer * >(argp1);
47622 {
47623 PyThreadState* __tstate = wxPyBeginAllowThreads();
47624 result = (PyObject *)wxSizer_GetChildren(arg1);
47625 wxPyEndAllowThreads(__tstate);
47626 if (PyErr_Occurred()) SWIG_fail;
47627 }
47628 resultobj = result;
47629 return resultobj;
47630 fail:
47631 return NULL;
47632 }
47633
47634
47635 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47636 PyObject *resultobj = 0;
47637 wxSizer *arg1 = (wxSizer *) 0 ;
47638 PyObject *arg2 = (PyObject *) 0 ;
47639 bool arg3 = (bool) true ;
47640 bool arg4 = (bool) false ;
47641 bool result;
47642 void *argp1 = 0 ;
47643 int res1 = 0 ;
47644 bool val3 ;
47645 int ecode3 = 0 ;
47646 bool val4 ;
47647 int ecode4 = 0 ;
47648 PyObject * obj0 = 0 ;
47649 PyObject * obj1 = 0 ;
47650 PyObject * obj2 = 0 ;
47651 PyObject * obj3 = 0 ;
47652 char * kwnames[] = {
47653 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47654 };
47655
47656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47658 if (!SWIG_IsOK(res1)) {
47659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47660 }
47661 arg1 = reinterpret_cast< wxSizer * >(argp1);
47662 arg2 = obj1;
47663 if (obj2) {
47664 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47665 if (!SWIG_IsOK(ecode3)) {
47666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47667 }
47668 arg3 = static_cast< bool >(val3);
47669 }
47670 if (obj3) {
47671 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47672 if (!SWIG_IsOK(ecode4)) {
47673 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47674 }
47675 arg4 = static_cast< bool >(val4);
47676 }
47677 {
47678 PyThreadState* __tstate = wxPyBeginAllowThreads();
47679 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47680 wxPyEndAllowThreads(__tstate);
47681 if (PyErr_Occurred()) SWIG_fail;
47682 }
47683 {
47684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47685 }
47686 return resultobj;
47687 fail:
47688 return NULL;
47689 }
47690
47691
47692 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47693 PyObject *resultobj = 0;
47694 wxSizer *arg1 = (wxSizer *) 0 ;
47695 PyObject *arg2 = (PyObject *) 0 ;
47696 bool result;
47697 void *argp1 = 0 ;
47698 int res1 = 0 ;
47699 PyObject * obj0 = 0 ;
47700 PyObject * obj1 = 0 ;
47701 char * kwnames[] = {
47702 (char *) "self",(char *) "item", NULL
47703 };
47704
47705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47707 if (!SWIG_IsOK(res1)) {
47708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47709 }
47710 arg1 = reinterpret_cast< wxSizer * >(argp1);
47711 arg2 = obj1;
47712 {
47713 PyThreadState* __tstate = wxPyBeginAllowThreads();
47714 result = (bool)wxSizer_IsShown(arg1,arg2);
47715 wxPyEndAllowThreads(__tstate);
47716 if (PyErr_Occurred()) SWIG_fail;
47717 }
47718 {
47719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47720 }
47721 return resultobj;
47722 fail:
47723 return NULL;
47724 }
47725
47726
47727 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47728 PyObject *resultobj = 0;
47729 wxSizer *arg1 = (wxSizer *) 0 ;
47730 bool arg2 ;
47731 void *argp1 = 0 ;
47732 int res1 = 0 ;
47733 bool val2 ;
47734 int ecode2 = 0 ;
47735 PyObject * obj0 = 0 ;
47736 PyObject * obj1 = 0 ;
47737 char * kwnames[] = {
47738 (char *) "self",(char *) "show", NULL
47739 };
47740
47741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47743 if (!SWIG_IsOK(res1)) {
47744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47745 }
47746 arg1 = reinterpret_cast< wxSizer * >(argp1);
47747 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47748 if (!SWIG_IsOK(ecode2)) {
47749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47750 }
47751 arg2 = static_cast< bool >(val2);
47752 {
47753 PyThreadState* __tstate = wxPyBeginAllowThreads();
47754 (arg1)->ShowItems(arg2);
47755 wxPyEndAllowThreads(__tstate);
47756 if (PyErr_Occurred()) SWIG_fail;
47757 }
47758 resultobj = SWIG_Py_Void();
47759 return resultobj;
47760 fail:
47761 return NULL;
47762 }
47763
47764
47765 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47766 PyObject *obj;
47767 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47768 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47769 return SWIG_Py_Void();
47770 }
47771
47772 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47773 PyObject *resultobj = 0;
47774 wxPySizer *result = 0 ;
47775
47776 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47777 {
47778 PyThreadState* __tstate = wxPyBeginAllowThreads();
47779 result = (wxPySizer *)new wxPySizer();
47780 wxPyEndAllowThreads(__tstate);
47781 if (PyErr_Occurred()) SWIG_fail;
47782 }
47783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47784 return resultobj;
47785 fail:
47786 return NULL;
47787 }
47788
47789
47790 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47791 PyObject *resultobj = 0;
47792 wxPySizer *arg1 = (wxPySizer *) 0 ;
47793 PyObject *arg2 = (PyObject *) 0 ;
47794 PyObject *arg3 = (PyObject *) 0 ;
47795 void *argp1 = 0 ;
47796 int res1 = 0 ;
47797 PyObject * obj0 = 0 ;
47798 PyObject * obj1 = 0 ;
47799 PyObject * obj2 = 0 ;
47800 char * kwnames[] = {
47801 (char *) "self",(char *) "self",(char *) "_class", NULL
47802 };
47803
47804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47806 if (!SWIG_IsOK(res1)) {
47807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47808 }
47809 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47810 arg2 = obj1;
47811 arg3 = obj2;
47812 {
47813 PyThreadState* __tstate = wxPyBeginAllowThreads();
47814 (arg1)->_setCallbackInfo(arg2,arg3);
47815 wxPyEndAllowThreads(__tstate);
47816 if (PyErr_Occurred()) SWIG_fail;
47817 }
47818 resultobj = SWIG_Py_Void();
47819 return resultobj;
47820 fail:
47821 return NULL;
47822 }
47823
47824
47825 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47826 PyObject *obj;
47827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47828 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47829 return SWIG_Py_Void();
47830 }
47831
47832 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47833 return SWIG_Python_InitShadowInstance(args);
47834 }
47835
47836 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47837 PyObject *resultobj = 0;
47838 int arg1 = (int) wxHORIZONTAL ;
47839 wxBoxSizer *result = 0 ;
47840 int val1 ;
47841 int ecode1 = 0 ;
47842 PyObject * obj0 = 0 ;
47843 char * kwnames[] = {
47844 (char *) "orient", NULL
47845 };
47846
47847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47848 if (obj0) {
47849 ecode1 = SWIG_AsVal_int(obj0, &val1);
47850 if (!SWIG_IsOK(ecode1)) {
47851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47852 }
47853 arg1 = static_cast< int >(val1);
47854 }
47855 {
47856 PyThreadState* __tstate = wxPyBeginAllowThreads();
47857 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47858 wxPyEndAllowThreads(__tstate);
47859 if (PyErr_Occurred()) SWIG_fail;
47860 }
47861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47862 return resultobj;
47863 fail:
47864 return NULL;
47865 }
47866
47867
47868 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47869 PyObject *resultobj = 0;
47870 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47871 int result;
47872 void *argp1 = 0 ;
47873 int res1 = 0 ;
47874 PyObject *swig_obj[1] ;
47875
47876 if (!args) SWIG_fail;
47877 swig_obj[0] = args;
47878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47879 if (!SWIG_IsOK(res1)) {
47880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47881 }
47882 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47883 {
47884 PyThreadState* __tstate = wxPyBeginAllowThreads();
47885 result = (int)(arg1)->GetOrientation();
47886 wxPyEndAllowThreads(__tstate);
47887 if (PyErr_Occurred()) SWIG_fail;
47888 }
47889 resultobj = SWIG_From_int(static_cast< int >(result));
47890 return resultobj;
47891 fail:
47892 return NULL;
47893 }
47894
47895
47896 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47897 PyObject *resultobj = 0;
47898 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47899 int arg2 ;
47900 void *argp1 = 0 ;
47901 int res1 = 0 ;
47902 int val2 ;
47903 int ecode2 = 0 ;
47904 PyObject * obj0 = 0 ;
47905 PyObject * obj1 = 0 ;
47906 char * kwnames[] = {
47907 (char *) "self",(char *) "orient", NULL
47908 };
47909
47910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47912 if (!SWIG_IsOK(res1)) {
47913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47914 }
47915 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47916 ecode2 = SWIG_AsVal_int(obj1, &val2);
47917 if (!SWIG_IsOK(ecode2)) {
47918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47919 }
47920 arg2 = static_cast< int >(val2);
47921 {
47922 PyThreadState* __tstate = wxPyBeginAllowThreads();
47923 (arg1)->SetOrientation(arg2);
47924 wxPyEndAllowThreads(__tstate);
47925 if (PyErr_Occurred()) SWIG_fail;
47926 }
47927 resultobj = SWIG_Py_Void();
47928 return resultobj;
47929 fail:
47930 return NULL;
47931 }
47932
47933
47934 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47935 PyObject *obj;
47936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47937 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47938 return SWIG_Py_Void();
47939 }
47940
47941 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47942 return SWIG_Python_InitShadowInstance(args);
47943 }
47944
47945 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47946 PyObject *resultobj = 0;
47947 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47948 int arg2 = (int) wxHORIZONTAL ;
47949 wxStaticBoxSizer *result = 0 ;
47950 void *argp1 = 0 ;
47951 int res1 = 0 ;
47952 int val2 ;
47953 int ecode2 = 0 ;
47954 PyObject * obj0 = 0 ;
47955 PyObject * obj1 = 0 ;
47956 char * kwnames[] = {
47957 (char *) "box",(char *) "orient", NULL
47958 };
47959
47960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47962 if (!SWIG_IsOK(res1)) {
47963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47964 }
47965 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47966 if (obj1) {
47967 ecode2 = SWIG_AsVal_int(obj1, &val2);
47968 if (!SWIG_IsOK(ecode2)) {
47969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47970 }
47971 arg2 = static_cast< int >(val2);
47972 }
47973 {
47974 PyThreadState* __tstate = wxPyBeginAllowThreads();
47975 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47976 wxPyEndAllowThreads(__tstate);
47977 if (PyErr_Occurred()) SWIG_fail;
47978 }
47979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47980 return resultobj;
47981 fail:
47982 return NULL;
47983 }
47984
47985
47986 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47987 PyObject *resultobj = 0;
47988 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47989 wxStaticBox *result = 0 ;
47990 void *argp1 = 0 ;
47991 int res1 = 0 ;
47992 PyObject *swig_obj[1] ;
47993
47994 if (!args) SWIG_fail;
47995 swig_obj[0] = args;
47996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47997 if (!SWIG_IsOK(res1)) {
47998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47999 }
48000 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48001 {
48002 PyThreadState* __tstate = wxPyBeginAllowThreads();
48003 result = (wxStaticBox *)(arg1)->GetStaticBox();
48004 wxPyEndAllowThreads(__tstate);
48005 if (PyErr_Occurred()) SWIG_fail;
48006 }
48007 {
48008 resultobj = wxPyMake_wxObject(result, (bool)0);
48009 }
48010 return resultobj;
48011 fail:
48012 return NULL;
48013 }
48014
48015
48016 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48017 PyObject *obj;
48018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48019 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48020 return SWIG_Py_Void();
48021 }
48022
48023 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48024 return SWIG_Python_InitShadowInstance(args);
48025 }
48026
48027 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48028 PyObject *resultobj = 0;
48029 int arg1 = (int) 1 ;
48030 int arg2 = (int) 0 ;
48031 int arg3 = (int) 0 ;
48032 int arg4 = (int) 0 ;
48033 wxGridSizer *result = 0 ;
48034 int val1 ;
48035 int ecode1 = 0 ;
48036 int val2 ;
48037 int ecode2 = 0 ;
48038 int val3 ;
48039 int ecode3 = 0 ;
48040 int val4 ;
48041 int ecode4 = 0 ;
48042 PyObject * obj0 = 0 ;
48043 PyObject * obj1 = 0 ;
48044 PyObject * obj2 = 0 ;
48045 PyObject * obj3 = 0 ;
48046 char * kwnames[] = {
48047 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48048 };
48049
48050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48051 if (obj0) {
48052 ecode1 = SWIG_AsVal_int(obj0, &val1);
48053 if (!SWIG_IsOK(ecode1)) {
48054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48055 }
48056 arg1 = static_cast< int >(val1);
48057 }
48058 if (obj1) {
48059 ecode2 = SWIG_AsVal_int(obj1, &val2);
48060 if (!SWIG_IsOK(ecode2)) {
48061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48062 }
48063 arg2 = static_cast< int >(val2);
48064 }
48065 if (obj2) {
48066 ecode3 = SWIG_AsVal_int(obj2, &val3);
48067 if (!SWIG_IsOK(ecode3)) {
48068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48069 }
48070 arg3 = static_cast< int >(val3);
48071 }
48072 if (obj3) {
48073 ecode4 = SWIG_AsVal_int(obj3, &val4);
48074 if (!SWIG_IsOK(ecode4)) {
48075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48076 }
48077 arg4 = static_cast< int >(val4);
48078 }
48079 {
48080 PyThreadState* __tstate = wxPyBeginAllowThreads();
48081 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48082 wxPyEndAllowThreads(__tstate);
48083 if (PyErr_Occurred()) SWIG_fail;
48084 }
48085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48086 return resultobj;
48087 fail:
48088 return NULL;
48089 }
48090
48091
48092 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48093 PyObject *resultobj = 0;
48094 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48095 int arg2 ;
48096 void *argp1 = 0 ;
48097 int res1 = 0 ;
48098 int val2 ;
48099 int ecode2 = 0 ;
48100 PyObject * obj0 = 0 ;
48101 PyObject * obj1 = 0 ;
48102 char * kwnames[] = {
48103 (char *) "self",(char *) "cols", NULL
48104 };
48105
48106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48108 if (!SWIG_IsOK(res1)) {
48109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48110 }
48111 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48112 ecode2 = SWIG_AsVal_int(obj1, &val2);
48113 if (!SWIG_IsOK(ecode2)) {
48114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48115 }
48116 arg2 = static_cast< int >(val2);
48117 {
48118 PyThreadState* __tstate = wxPyBeginAllowThreads();
48119 (arg1)->SetCols(arg2);
48120 wxPyEndAllowThreads(__tstate);
48121 if (PyErr_Occurred()) SWIG_fail;
48122 }
48123 resultobj = SWIG_Py_Void();
48124 return resultobj;
48125 fail:
48126 return NULL;
48127 }
48128
48129
48130 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48131 PyObject *resultobj = 0;
48132 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48133 int arg2 ;
48134 void *argp1 = 0 ;
48135 int res1 = 0 ;
48136 int val2 ;
48137 int ecode2 = 0 ;
48138 PyObject * obj0 = 0 ;
48139 PyObject * obj1 = 0 ;
48140 char * kwnames[] = {
48141 (char *) "self",(char *) "rows", NULL
48142 };
48143
48144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48146 if (!SWIG_IsOK(res1)) {
48147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48148 }
48149 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48150 ecode2 = SWIG_AsVal_int(obj1, &val2);
48151 if (!SWIG_IsOK(ecode2)) {
48152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48153 }
48154 arg2 = static_cast< int >(val2);
48155 {
48156 PyThreadState* __tstate = wxPyBeginAllowThreads();
48157 (arg1)->SetRows(arg2);
48158 wxPyEndAllowThreads(__tstate);
48159 if (PyErr_Occurred()) SWIG_fail;
48160 }
48161 resultobj = SWIG_Py_Void();
48162 return resultobj;
48163 fail:
48164 return NULL;
48165 }
48166
48167
48168 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48169 PyObject *resultobj = 0;
48170 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48171 int arg2 ;
48172 void *argp1 = 0 ;
48173 int res1 = 0 ;
48174 int val2 ;
48175 int ecode2 = 0 ;
48176 PyObject * obj0 = 0 ;
48177 PyObject * obj1 = 0 ;
48178 char * kwnames[] = {
48179 (char *) "self",(char *) "gap", NULL
48180 };
48181
48182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48184 if (!SWIG_IsOK(res1)) {
48185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48186 }
48187 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48188 ecode2 = SWIG_AsVal_int(obj1, &val2);
48189 if (!SWIG_IsOK(ecode2)) {
48190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48191 }
48192 arg2 = static_cast< int >(val2);
48193 {
48194 PyThreadState* __tstate = wxPyBeginAllowThreads();
48195 (arg1)->SetVGap(arg2);
48196 wxPyEndAllowThreads(__tstate);
48197 if (PyErr_Occurred()) SWIG_fail;
48198 }
48199 resultobj = SWIG_Py_Void();
48200 return resultobj;
48201 fail:
48202 return NULL;
48203 }
48204
48205
48206 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48207 PyObject *resultobj = 0;
48208 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48209 int arg2 ;
48210 void *argp1 = 0 ;
48211 int res1 = 0 ;
48212 int val2 ;
48213 int ecode2 = 0 ;
48214 PyObject * obj0 = 0 ;
48215 PyObject * obj1 = 0 ;
48216 char * kwnames[] = {
48217 (char *) "self",(char *) "gap", NULL
48218 };
48219
48220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48222 if (!SWIG_IsOK(res1)) {
48223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48224 }
48225 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48226 ecode2 = SWIG_AsVal_int(obj1, &val2);
48227 if (!SWIG_IsOK(ecode2)) {
48228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48229 }
48230 arg2 = static_cast< int >(val2);
48231 {
48232 PyThreadState* __tstate = wxPyBeginAllowThreads();
48233 (arg1)->SetHGap(arg2);
48234 wxPyEndAllowThreads(__tstate);
48235 if (PyErr_Occurred()) SWIG_fail;
48236 }
48237 resultobj = SWIG_Py_Void();
48238 return resultobj;
48239 fail:
48240 return NULL;
48241 }
48242
48243
48244 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48245 PyObject *resultobj = 0;
48246 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48247 int result;
48248 void *argp1 = 0 ;
48249 int res1 = 0 ;
48250 PyObject *swig_obj[1] ;
48251
48252 if (!args) SWIG_fail;
48253 swig_obj[0] = args;
48254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48255 if (!SWIG_IsOK(res1)) {
48256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48257 }
48258 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48259 {
48260 PyThreadState* __tstate = wxPyBeginAllowThreads();
48261 result = (int)(arg1)->GetCols();
48262 wxPyEndAllowThreads(__tstate);
48263 if (PyErr_Occurred()) SWIG_fail;
48264 }
48265 resultobj = SWIG_From_int(static_cast< int >(result));
48266 return resultobj;
48267 fail:
48268 return NULL;
48269 }
48270
48271
48272 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48273 PyObject *resultobj = 0;
48274 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48275 int result;
48276 void *argp1 = 0 ;
48277 int res1 = 0 ;
48278 PyObject *swig_obj[1] ;
48279
48280 if (!args) SWIG_fail;
48281 swig_obj[0] = args;
48282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48283 if (!SWIG_IsOK(res1)) {
48284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48285 }
48286 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48287 {
48288 PyThreadState* __tstate = wxPyBeginAllowThreads();
48289 result = (int)(arg1)->GetRows();
48290 wxPyEndAllowThreads(__tstate);
48291 if (PyErr_Occurred()) SWIG_fail;
48292 }
48293 resultobj = SWIG_From_int(static_cast< int >(result));
48294 return resultobj;
48295 fail:
48296 return NULL;
48297 }
48298
48299
48300 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48301 PyObject *resultobj = 0;
48302 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48303 int result;
48304 void *argp1 = 0 ;
48305 int res1 = 0 ;
48306 PyObject *swig_obj[1] ;
48307
48308 if (!args) SWIG_fail;
48309 swig_obj[0] = args;
48310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48311 if (!SWIG_IsOK(res1)) {
48312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48313 }
48314 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48315 {
48316 PyThreadState* __tstate = wxPyBeginAllowThreads();
48317 result = (int)(arg1)->GetVGap();
48318 wxPyEndAllowThreads(__tstate);
48319 if (PyErr_Occurred()) SWIG_fail;
48320 }
48321 resultobj = SWIG_From_int(static_cast< int >(result));
48322 return resultobj;
48323 fail:
48324 return NULL;
48325 }
48326
48327
48328 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48329 PyObject *resultobj = 0;
48330 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48331 int result;
48332 void *argp1 = 0 ;
48333 int res1 = 0 ;
48334 PyObject *swig_obj[1] ;
48335
48336 if (!args) SWIG_fail;
48337 swig_obj[0] = args;
48338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48339 if (!SWIG_IsOK(res1)) {
48340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48341 }
48342 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48343 {
48344 PyThreadState* __tstate = wxPyBeginAllowThreads();
48345 result = (int)(arg1)->GetHGap();
48346 wxPyEndAllowThreads(__tstate);
48347 if (PyErr_Occurred()) SWIG_fail;
48348 }
48349 resultobj = SWIG_From_int(static_cast< int >(result));
48350 return resultobj;
48351 fail:
48352 return NULL;
48353 }
48354
48355
48356 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48357 PyObject *obj;
48358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48359 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48360 return SWIG_Py_Void();
48361 }
48362
48363 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48364 return SWIG_Python_InitShadowInstance(args);
48365 }
48366
48367 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48368 PyObject *resultobj = 0;
48369 int arg1 = (int) 1 ;
48370 int arg2 = (int) 0 ;
48371 int arg3 = (int) 0 ;
48372 int arg4 = (int) 0 ;
48373 wxFlexGridSizer *result = 0 ;
48374 int val1 ;
48375 int ecode1 = 0 ;
48376 int val2 ;
48377 int ecode2 = 0 ;
48378 int val3 ;
48379 int ecode3 = 0 ;
48380 int val4 ;
48381 int ecode4 = 0 ;
48382 PyObject * obj0 = 0 ;
48383 PyObject * obj1 = 0 ;
48384 PyObject * obj2 = 0 ;
48385 PyObject * obj3 = 0 ;
48386 char * kwnames[] = {
48387 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48388 };
48389
48390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48391 if (obj0) {
48392 ecode1 = SWIG_AsVal_int(obj0, &val1);
48393 if (!SWIG_IsOK(ecode1)) {
48394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48395 }
48396 arg1 = static_cast< int >(val1);
48397 }
48398 if (obj1) {
48399 ecode2 = SWIG_AsVal_int(obj1, &val2);
48400 if (!SWIG_IsOK(ecode2)) {
48401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48402 }
48403 arg2 = static_cast< int >(val2);
48404 }
48405 if (obj2) {
48406 ecode3 = SWIG_AsVal_int(obj2, &val3);
48407 if (!SWIG_IsOK(ecode3)) {
48408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48409 }
48410 arg3 = static_cast< int >(val3);
48411 }
48412 if (obj3) {
48413 ecode4 = SWIG_AsVal_int(obj3, &val4);
48414 if (!SWIG_IsOK(ecode4)) {
48415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48416 }
48417 arg4 = static_cast< int >(val4);
48418 }
48419 {
48420 PyThreadState* __tstate = wxPyBeginAllowThreads();
48421 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48422 wxPyEndAllowThreads(__tstate);
48423 if (PyErr_Occurred()) SWIG_fail;
48424 }
48425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48426 return resultobj;
48427 fail:
48428 return NULL;
48429 }
48430
48431
48432 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48433 PyObject *resultobj = 0;
48434 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48435 size_t arg2 ;
48436 int arg3 = (int) 0 ;
48437 void *argp1 = 0 ;
48438 int res1 = 0 ;
48439 size_t val2 ;
48440 int ecode2 = 0 ;
48441 int val3 ;
48442 int ecode3 = 0 ;
48443 PyObject * obj0 = 0 ;
48444 PyObject * obj1 = 0 ;
48445 PyObject * obj2 = 0 ;
48446 char * kwnames[] = {
48447 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48448 };
48449
48450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48452 if (!SWIG_IsOK(res1)) {
48453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48454 }
48455 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48456 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48457 if (!SWIG_IsOK(ecode2)) {
48458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48459 }
48460 arg2 = static_cast< size_t >(val2);
48461 if (obj2) {
48462 ecode3 = SWIG_AsVal_int(obj2, &val3);
48463 if (!SWIG_IsOK(ecode3)) {
48464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48465 }
48466 arg3 = static_cast< int >(val3);
48467 }
48468 {
48469 PyThreadState* __tstate = wxPyBeginAllowThreads();
48470 (arg1)->AddGrowableRow(arg2,arg3);
48471 wxPyEndAllowThreads(__tstate);
48472 if (PyErr_Occurred()) SWIG_fail;
48473 }
48474 resultobj = SWIG_Py_Void();
48475 return resultobj;
48476 fail:
48477 return NULL;
48478 }
48479
48480
48481 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48482 PyObject *resultobj = 0;
48483 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48484 size_t arg2 ;
48485 void *argp1 = 0 ;
48486 int res1 = 0 ;
48487 size_t val2 ;
48488 int ecode2 = 0 ;
48489 PyObject * obj0 = 0 ;
48490 PyObject * obj1 = 0 ;
48491 char * kwnames[] = {
48492 (char *) "self",(char *) "idx", NULL
48493 };
48494
48495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48497 if (!SWIG_IsOK(res1)) {
48498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48499 }
48500 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48501 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48502 if (!SWIG_IsOK(ecode2)) {
48503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48504 }
48505 arg2 = static_cast< size_t >(val2);
48506 {
48507 PyThreadState* __tstate = wxPyBeginAllowThreads();
48508 (arg1)->RemoveGrowableRow(arg2);
48509 wxPyEndAllowThreads(__tstate);
48510 if (PyErr_Occurred()) SWIG_fail;
48511 }
48512 resultobj = SWIG_Py_Void();
48513 return resultobj;
48514 fail:
48515 return NULL;
48516 }
48517
48518
48519 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48520 PyObject *resultobj = 0;
48521 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48522 size_t arg2 ;
48523 int arg3 = (int) 0 ;
48524 void *argp1 = 0 ;
48525 int res1 = 0 ;
48526 size_t val2 ;
48527 int ecode2 = 0 ;
48528 int val3 ;
48529 int ecode3 = 0 ;
48530 PyObject * obj0 = 0 ;
48531 PyObject * obj1 = 0 ;
48532 PyObject * obj2 = 0 ;
48533 char * kwnames[] = {
48534 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48535 };
48536
48537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48539 if (!SWIG_IsOK(res1)) {
48540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48541 }
48542 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48543 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48544 if (!SWIG_IsOK(ecode2)) {
48545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48546 }
48547 arg2 = static_cast< size_t >(val2);
48548 if (obj2) {
48549 ecode3 = SWIG_AsVal_int(obj2, &val3);
48550 if (!SWIG_IsOK(ecode3)) {
48551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48552 }
48553 arg3 = static_cast< int >(val3);
48554 }
48555 {
48556 PyThreadState* __tstate = wxPyBeginAllowThreads();
48557 (arg1)->AddGrowableCol(arg2,arg3);
48558 wxPyEndAllowThreads(__tstate);
48559 if (PyErr_Occurred()) SWIG_fail;
48560 }
48561 resultobj = SWIG_Py_Void();
48562 return resultobj;
48563 fail:
48564 return NULL;
48565 }
48566
48567
48568 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48569 PyObject *resultobj = 0;
48570 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48571 size_t arg2 ;
48572 void *argp1 = 0 ;
48573 int res1 = 0 ;
48574 size_t val2 ;
48575 int ecode2 = 0 ;
48576 PyObject * obj0 = 0 ;
48577 PyObject * obj1 = 0 ;
48578 char * kwnames[] = {
48579 (char *) "self",(char *) "idx", NULL
48580 };
48581
48582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48584 if (!SWIG_IsOK(res1)) {
48585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48586 }
48587 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48588 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48589 if (!SWIG_IsOK(ecode2)) {
48590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48591 }
48592 arg2 = static_cast< size_t >(val2);
48593 {
48594 PyThreadState* __tstate = wxPyBeginAllowThreads();
48595 (arg1)->RemoveGrowableCol(arg2);
48596 wxPyEndAllowThreads(__tstate);
48597 if (PyErr_Occurred()) SWIG_fail;
48598 }
48599 resultobj = SWIG_Py_Void();
48600 return resultobj;
48601 fail:
48602 return NULL;
48603 }
48604
48605
48606 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48607 PyObject *resultobj = 0;
48608 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48609 int arg2 ;
48610 void *argp1 = 0 ;
48611 int res1 = 0 ;
48612 int val2 ;
48613 int ecode2 = 0 ;
48614 PyObject * obj0 = 0 ;
48615 PyObject * obj1 = 0 ;
48616 char * kwnames[] = {
48617 (char *) "self",(char *) "direction", NULL
48618 };
48619
48620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48622 if (!SWIG_IsOK(res1)) {
48623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48624 }
48625 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48626 ecode2 = SWIG_AsVal_int(obj1, &val2);
48627 if (!SWIG_IsOK(ecode2)) {
48628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48629 }
48630 arg2 = static_cast< int >(val2);
48631 {
48632 PyThreadState* __tstate = wxPyBeginAllowThreads();
48633 (arg1)->SetFlexibleDirection(arg2);
48634 wxPyEndAllowThreads(__tstate);
48635 if (PyErr_Occurred()) SWIG_fail;
48636 }
48637 resultobj = SWIG_Py_Void();
48638 return resultobj;
48639 fail:
48640 return NULL;
48641 }
48642
48643
48644 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48645 PyObject *resultobj = 0;
48646 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48647 int result;
48648 void *argp1 = 0 ;
48649 int res1 = 0 ;
48650 PyObject *swig_obj[1] ;
48651
48652 if (!args) SWIG_fail;
48653 swig_obj[0] = args;
48654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48655 if (!SWIG_IsOK(res1)) {
48656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48657 }
48658 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48659 {
48660 PyThreadState* __tstate = wxPyBeginAllowThreads();
48661 result = (int)(arg1)->GetFlexibleDirection();
48662 wxPyEndAllowThreads(__tstate);
48663 if (PyErr_Occurred()) SWIG_fail;
48664 }
48665 resultobj = SWIG_From_int(static_cast< int >(result));
48666 return resultobj;
48667 fail:
48668 return NULL;
48669 }
48670
48671
48672 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48673 PyObject *resultobj = 0;
48674 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48675 wxFlexSizerGrowMode arg2 ;
48676 void *argp1 = 0 ;
48677 int res1 = 0 ;
48678 int val2 ;
48679 int ecode2 = 0 ;
48680 PyObject * obj0 = 0 ;
48681 PyObject * obj1 = 0 ;
48682 char * kwnames[] = {
48683 (char *) "self",(char *) "mode", NULL
48684 };
48685
48686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48688 if (!SWIG_IsOK(res1)) {
48689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48690 }
48691 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48692 ecode2 = SWIG_AsVal_int(obj1, &val2);
48693 if (!SWIG_IsOK(ecode2)) {
48694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48695 }
48696 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48697 {
48698 PyThreadState* __tstate = wxPyBeginAllowThreads();
48699 (arg1)->SetNonFlexibleGrowMode(arg2);
48700 wxPyEndAllowThreads(__tstate);
48701 if (PyErr_Occurred()) SWIG_fail;
48702 }
48703 resultobj = SWIG_Py_Void();
48704 return resultobj;
48705 fail:
48706 return NULL;
48707 }
48708
48709
48710 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48711 PyObject *resultobj = 0;
48712 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48713 wxFlexSizerGrowMode result;
48714 void *argp1 = 0 ;
48715 int res1 = 0 ;
48716 PyObject *swig_obj[1] ;
48717
48718 if (!args) SWIG_fail;
48719 swig_obj[0] = args;
48720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48721 if (!SWIG_IsOK(res1)) {
48722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48723 }
48724 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48725 {
48726 PyThreadState* __tstate = wxPyBeginAllowThreads();
48727 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48728 wxPyEndAllowThreads(__tstate);
48729 if (PyErr_Occurred()) SWIG_fail;
48730 }
48731 resultobj = SWIG_From_int(static_cast< int >(result));
48732 return resultobj;
48733 fail:
48734 return NULL;
48735 }
48736
48737
48738 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48739 PyObject *resultobj = 0;
48740 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48741 wxArrayInt *result = 0 ;
48742 void *argp1 = 0 ;
48743 int res1 = 0 ;
48744 PyObject *swig_obj[1] ;
48745
48746 if (!args) SWIG_fail;
48747 swig_obj[0] = args;
48748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48749 if (!SWIG_IsOK(res1)) {
48750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48751 }
48752 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48753 {
48754 PyThreadState* __tstate = wxPyBeginAllowThreads();
48755 {
48756 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48757 result = (wxArrayInt *) &_result_ref;
48758 }
48759 wxPyEndAllowThreads(__tstate);
48760 if (PyErr_Occurred()) SWIG_fail;
48761 }
48762 {
48763 resultobj = PyList_New(0);
48764 size_t idx;
48765 for (idx = 0; idx < result->GetCount(); idx += 1) {
48766 PyObject* val = PyInt_FromLong( result->Item(idx) );
48767 PyList_Append(resultobj, val);
48768 Py_DECREF(val);
48769 }
48770 }
48771 return resultobj;
48772 fail:
48773 return NULL;
48774 }
48775
48776
48777 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48778 PyObject *resultobj = 0;
48779 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48780 wxArrayInt *result = 0 ;
48781 void *argp1 = 0 ;
48782 int res1 = 0 ;
48783 PyObject *swig_obj[1] ;
48784
48785 if (!args) SWIG_fail;
48786 swig_obj[0] = args;
48787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48788 if (!SWIG_IsOK(res1)) {
48789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48790 }
48791 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48792 {
48793 PyThreadState* __tstate = wxPyBeginAllowThreads();
48794 {
48795 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48796 result = (wxArrayInt *) &_result_ref;
48797 }
48798 wxPyEndAllowThreads(__tstate);
48799 if (PyErr_Occurred()) SWIG_fail;
48800 }
48801 {
48802 resultobj = PyList_New(0);
48803 size_t idx;
48804 for (idx = 0; idx < result->GetCount(); idx += 1) {
48805 PyObject* val = PyInt_FromLong( result->Item(idx) );
48806 PyList_Append(resultobj, val);
48807 Py_DECREF(val);
48808 }
48809 }
48810 return resultobj;
48811 fail:
48812 return NULL;
48813 }
48814
48815
48816 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48817 PyObject *obj;
48818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48819 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48820 return SWIG_Py_Void();
48821 }
48822
48823 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48824 return SWIG_Python_InitShadowInstance(args);
48825 }
48826
48827 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48828 PyObject *resultobj = 0;
48829 wxStdDialogButtonSizer *result = 0 ;
48830
48831 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48832 {
48833 PyThreadState* __tstate = wxPyBeginAllowThreads();
48834 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48835 wxPyEndAllowThreads(__tstate);
48836 if (PyErr_Occurred()) SWIG_fail;
48837 }
48838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48839 return resultobj;
48840 fail:
48841 return NULL;
48842 }
48843
48844
48845 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48846 PyObject *resultobj = 0;
48847 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48848 wxButton *arg2 = (wxButton *) 0 ;
48849 void *argp1 = 0 ;
48850 int res1 = 0 ;
48851 void *argp2 = 0 ;
48852 int res2 = 0 ;
48853 PyObject * obj0 = 0 ;
48854 PyObject * obj1 = 0 ;
48855 char * kwnames[] = {
48856 (char *) "self",(char *) "button", NULL
48857 };
48858
48859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48861 if (!SWIG_IsOK(res1)) {
48862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48863 }
48864 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48866 if (!SWIG_IsOK(res2)) {
48867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48868 }
48869 arg2 = reinterpret_cast< wxButton * >(argp2);
48870 {
48871 PyThreadState* __tstate = wxPyBeginAllowThreads();
48872 (arg1)->AddButton(arg2);
48873 wxPyEndAllowThreads(__tstate);
48874 if (PyErr_Occurred()) SWIG_fail;
48875 }
48876 resultobj = SWIG_Py_Void();
48877 return resultobj;
48878 fail:
48879 return NULL;
48880 }
48881
48882
48883 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48884 PyObject *resultobj = 0;
48885 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48886 void *argp1 = 0 ;
48887 int res1 = 0 ;
48888 PyObject *swig_obj[1] ;
48889
48890 if (!args) SWIG_fail;
48891 swig_obj[0] = args;
48892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48893 if (!SWIG_IsOK(res1)) {
48894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48895 }
48896 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48897 {
48898 PyThreadState* __tstate = wxPyBeginAllowThreads();
48899 (arg1)->Realize();
48900 wxPyEndAllowThreads(__tstate);
48901 if (PyErr_Occurred()) SWIG_fail;
48902 }
48903 resultobj = SWIG_Py_Void();
48904 return resultobj;
48905 fail:
48906 return NULL;
48907 }
48908
48909
48910 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48911 PyObject *resultobj = 0;
48912 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48913 wxButton *arg2 = (wxButton *) 0 ;
48914 void *argp1 = 0 ;
48915 int res1 = 0 ;
48916 void *argp2 = 0 ;
48917 int res2 = 0 ;
48918 PyObject * obj0 = 0 ;
48919 PyObject * obj1 = 0 ;
48920 char * kwnames[] = {
48921 (char *) "self",(char *) "button", NULL
48922 };
48923
48924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48926 if (!SWIG_IsOK(res1)) {
48927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48928 }
48929 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48931 if (!SWIG_IsOK(res2)) {
48932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48933 }
48934 arg2 = reinterpret_cast< wxButton * >(argp2);
48935 {
48936 PyThreadState* __tstate = wxPyBeginAllowThreads();
48937 (arg1)->SetAffirmativeButton(arg2);
48938 wxPyEndAllowThreads(__tstate);
48939 if (PyErr_Occurred()) SWIG_fail;
48940 }
48941 resultobj = SWIG_Py_Void();
48942 return resultobj;
48943 fail:
48944 return NULL;
48945 }
48946
48947
48948 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48949 PyObject *resultobj = 0;
48950 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48951 wxButton *arg2 = (wxButton *) 0 ;
48952 void *argp1 = 0 ;
48953 int res1 = 0 ;
48954 void *argp2 = 0 ;
48955 int res2 = 0 ;
48956 PyObject * obj0 = 0 ;
48957 PyObject * obj1 = 0 ;
48958 char * kwnames[] = {
48959 (char *) "self",(char *) "button", NULL
48960 };
48961
48962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48964 if (!SWIG_IsOK(res1)) {
48965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48966 }
48967 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48968 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48969 if (!SWIG_IsOK(res2)) {
48970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48971 }
48972 arg2 = reinterpret_cast< wxButton * >(argp2);
48973 {
48974 PyThreadState* __tstate = wxPyBeginAllowThreads();
48975 (arg1)->SetNegativeButton(arg2);
48976 wxPyEndAllowThreads(__tstate);
48977 if (PyErr_Occurred()) SWIG_fail;
48978 }
48979 resultobj = SWIG_Py_Void();
48980 return resultobj;
48981 fail:
48982 return NULL;
48983 }
48984
48985
48986 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48987 PyObject *resultobj = 0;
48988 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48989 wxButton *arg2 = (wxButton *) 0 ;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 void *argp2 = 0 ;
48993 int res2 = 0 ;
48994 PyObject * obj0 = 0 ;
48995 PyObject * obj1 = 0 ;
48996 char * kwnames[] = {
48997 (char *) "self",(char *) "button", NULL
48998 };
48999
49000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49002 if (!SWIG_IsOK(res1)) {
49003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49004 }
49005 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49006 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49007 if (!SWIG_IsOK(res2)) {
49008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49009 }
49010 arg2 = reinterpret_cast< wxButton * >(argp2);
49011 {
49012 PyThreadState* __tstate = wxPyBeginAllowThreads();
49013 (arg1)->SetCancelButton(arg2);
49014 wxPyEndAllowThreads(__tstate);
49015 if (PyErr_Occurred()) SWIG_fail;
49016 }
49017 resultobj = SWIG_Py_Void();
49018 return resultobj;
49019 fail:
49020 return NULL;
49021 }
49022
49023
49024 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49025 PyObject *resultobj = 0;
49026 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49027 wxButton *result = 0 ;
49028 void *argp1 = 0 ;
49029 int res1 = 0 ;
49030 PyObject *swig_obj[1] ;
49031
49032 if (!args) SWIG_fail;
49033 swig_obj[0] = args;
49034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49035 if (!SWIG_IsOK(res1)) {
49036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49037 }
49038 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49039 {
49040 PyThreadState* __tstate = wxPyBeginAllowThreads();
49041 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49042 wxPyEndAllowThreads(__tstate);
49043 if (PyErr_Occurred()) SWIG_fail;
49044 }
49045 {
49046 resultobj = wxPyMake_wxObject(result, (bool)0);
49047 }
49048 return resultobj;
49049 fail:
49050 return NULL;
49051 }
49052
49053
49054 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49055 PyObject *resultobj = 0;
49056 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49057 wxButton *result = 0 ;
49058 void *argp1 = 0 ;
49059 int res1 = 0 ;
49060 PyObject *swig_obj[1] ;
49061
49062 if (!args) SWIG_fail;
49063 swig_obj[0] = args;
49064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49065 if (!SWIG_IsOK(res1)) {
49066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49067 }
49068 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49069 {
49070 PyThreadState* __tstate = wxPyBeginAllowThreads();
49071 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49072 wxPyEndAllowThreads(__tstate);
49073 if (PyErr_Occurred()) SWIG_fail;
49074 }
49075 {
49076 resultobj = wxPyMake_wxObject(result, (bool)0);
49077 }
49078 return resultobj;
49079 fail:
49080 return NULL;
49081 }
49082
49083
49084 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49085 PyObject *resultobj = 0;
49086 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49087 wxButton *result = 0 ;
49088 void *argp1 = 0 ;
49089 int res1 = 0 ;
49090 PyObject *swig_obj[1] ;
49091
49092 if (!args) SWIG_fail;
49093 swig_obj[0] = args;
49094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49095 if (!SWIG_IsOK(res1)) {
49096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49097 }
49098 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49099 {
49100 PyThreadState* __tstate = wxPyBeginAllowThreads();
49101 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49102 wxPyEndAllowThreads(__tstate);
49103 if (PyErr_Occurred()) SWIG_fail;
49104 }
49105 {
49106 resultobj = wxPyMake_wxObject(result, (bool)0);
49107 }
49108 return resultobj;
49109 fail:
49110 return NULL;
49111 }
49112
49113
49114 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49115 PyObject *resultobj = 0;
49116 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49117 wxButton *result = 0 ;
49118 void *argp1 = 0 ;
49119 int res1 = 0 ;
49120 PyObject *swig_obj[1] ;
49121
49122 if (!args) SWIG_fail;
49123 swig_obj[0] = args;
49124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49125 if (!SWIG_IsOK(res1)) {
49126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49127 }
49128 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49129 {
49130 PyThreadState* __tstate = wxPyBeginAllowThreads();
49131 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49132 wxPyEndAllowThreads(__tstate);
49133 if (PyErr_Occurred()) SWIG_fail;
49134 }
49135 {
49136 resultobj = wxPyMake_wxObject(result, (bool)0);
49137 }
49138 return resultobj;
49139 fail:
49140 return NULL;
49141 }
49142
49143
49144 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49145 PyObject *resultobj = 0;
49146 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49147 wxButton *result = 0 ;
49148 void *argp1 = 0 ;
49149 int res1 = 0 ;
49150 PyObject *swig_obj[1] ;
49151
49152 if (!args) SWIG_fail;
49153 swig_obj[0] = args;
49154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49155 if (!SWIG_IsOK(res1)) {
49156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49157 }
49158 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49159 {
49160 PyThreadState* __tstate = wxPyBeginAllowThreads();
49161 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49162 wxPyEndAllowThreads(__tstate);
49163 if (PyErr_Occurred()) SWIG_fail;
49164 }
49165 {
49166 resultobj = wxPyMake_wxObject(result, (bool)0);
49167 }
49168 return resultobj;
49169 fail:
49170 return NULL;
49171 }
49172
49173
49174 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49175 PyObject *obj;
49176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49177 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49178 return SWIG_Py_Void();
49179 }
49180
49181 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49182 return SWIG_Python_InitShadowInstance(args);
49183 }
49184
49185 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49186 PyObject *resultobj = 0;
49187 int arg1 = (int) 0 ;
49188 int arg2 = (int) 0 ;
49189 wxGBPosition *result = 0 ;
49190 int val1 ;
49191 int ecode1 = 0 ;
49192 int val2 ;
49193 int ecode2 = 0 ;
49194 PyObject * obj0 = 0 ;
49195 PyObject * obj1 = 0 ;
49196 char * kwnames[] = {
49197 (char *) "row",(char *) "col", NULL
49198 };
49199
49200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49201 if (obj0) {
49202 ecode1 = SWIG_AsVal_int(obj0, &val1);
49203 if (!SWIG_IsOK(ecode1)) {
49204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49205 }
49206 arg1 = static_cast< int >(val1);
49207 }
49208 if (obj1) {
49209 ecode2 = SWIG_AsVal_int(obj1, &val2);
49210 if (!SWIG_IsOK(ecode2)) {
49211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49212 }
49213 arg2 = static_cast< int >(val2);
49214 }
49215 {
49216 PyThreadState* __tstate = wxPyBeginAllowThreads();
49217 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49218 wxPyEndAllowThreads(__tstate);
49219 if (PyErr_Occurred()) SWIG_fail;
49220 }
49221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49222 return resultobj;
49223 fail:
49224 return NULL;
49225 }
49226
49227
49228 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49229 PyObject *resultobj = 0;
49230 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49231 void *argp1 = 0 ;
49232 int res1 = 0 ;
49233 PyObject *swig_obj[1] ;
49234
49235 if (!args) SWIG_fail;
49236 swig_obj[0] = args;
49237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49238 if (!SWIG_IsOK(res1)) {
49239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49240 }
49241 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49242 {
49243 PyThreadState* __tstate = wxPyBeginAllowThreads();
49244 delete arg1;
49245
49246 wxPyEndAllowThreads(__tstate);
49247 if (PyErr_Occurred()) SWIG_fail;
49248 }
49249 resultobj = SWIG_Py_Void();
49250 return resultobj;
49251 fail:
49252 return NULL;
49253 }
49254
49255
49256 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49257 PyObject *resultobj = 0;
49258 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49259 int result;
49260 void *argp1 = 0 ;
49261 int res1 = 0 ;
49262 PyObject *swig_obj[1] ;
49263
49264 if (!args) SWIG_fail;
49265 swig_obj[0] = args;
49266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49267 if (!SWIG_IsOK(res1)) {
49268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49269 }
49270 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49271 {
49272 PyThreadState* __tstate = wxPyBeginAllowThreads();
49273 result = (int)((wxGBPosition const *)arg1)->GetRow();
49274 wxPyEndAllowThreads(__tstate);
49275 if (PyErr_Occurred()) SWIG_fail;
49276 }
49277 resultobj = SWIG_From_int(static_cast< int >(result));
49278 return resultobj;
49279 fail:
49280 return NULL;
49281 }
49282
49283
49284 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49285 PyObject *resultobj = 0;
49286 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49287 int result;
49288 void *argp1 = 0 ;
49289 int res1 = 0 ;
49290 PyObject *swig_obj[1] ;
49291
49292 if (!args) SWIG_fail;
49293 swig_obj[0] = args;
49294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49295 if (!SWIG_IsOK(res1)) {
49296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49297 }
49298 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49299 {
49300 PyThreadState* __tstate = wxPyBeginAllowThreads();
49301 result = (int)((wxGBPosition const *)arg1)->GetCol();
49302 wxPyEndAllowThreads(__tstate);
49303 if (PyErr_Occurred()) SWIG_fail;
49304 }
49305 resultobj = SWIG_From_int(static_cast< int >(result));
49306 return resultobj;
49307 fail:
49308 return NULL;
49309 }
49310
49311
49312 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49313 PyObject *resultobj = 0;
49314 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49315 int arg2 ;
49316 void *argp1 = 0 ;
49317 int res1 = 0 ;
49318 int val2 ;
49319 int ecode2 = 0 ;
49320 PyObject * obj0 = 0 ;
49321 PyObject * obj1 = 0 ;
49322 char * kwnames[] = {
49323 (char *) "self",(char *) "row", NULL
49324 };
49325
49326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49328 if (!SWIG_IsOK(res1)) {
49329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49330 }
49331 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49332 ecode2 = SWIG_AsVal_int(obj1, &val2);
49333 if (!SWIG_IsOK(ecode2)) {
49334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49335 }
49336 arg2 = static_cast< int >(val2);
49337 {
49338 PyThreadState* __tstate = wxPyBeginAllowThreads();
49339 (arg1)->SetRow(arg2);
49340 wxPyEndAllowThreads(__tstate);
49341 if (PyErr_Occurred()) SWIG_fail;
49342 }
49343 resultobj = SWIG_Py_Void();
49344 return resultobj;
49345 fail:
49346 return NULL;
49347 }
49348
49349
49350 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49351 PyObject *resultobj = 0;
49352 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49353 int arg2 ;
49354 void *argp1 = 0 ;
49355 int res1 = 0 ;
49356 int val2 ;
49357 int ecode2 = 0 ;
49358 PyObject * obj0 = 0 ;
49359 PyObject * obj1 = 0 ;
49360 char * kwnames[] = {
49361 (char *) "self",(char *) "col", NULL
49362 };
49363
49364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49366 if (!SWIG_IsOK(res1)) {
49367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49368 }
49369 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49370 ecode2 = SWIG_AsVal_int(obj1, &val2);
49371 if (!SWIG_IsOK(ecode2)) {
49372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49373 }
49374 arg2 = static_cast< int >(val2);
49375 {
49376 PyThreadState* __tstate = wxPyBeginAllowThreads();
49377 (arg1)->SetCol(arg2);
49378 wxPyEndAllowThreads(__tstate);
49379 if (PyErr_Occurred()) SWIG_fail;
49380 }
49381 resultobj = SWIG_Py_Void();
49382 return resultobj;
49383 fail:
49384 return NULL;
49385 }
49386
49387
49388 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49389 PyObject *resultobj = 0;
49390 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49391 PyObject *arg2 = (PyObject *) 0 ;
49392 bool result;
49393 void *argp1 = 0 ;
49394 int res1 = 0 ;
49395 PyObject * obj0 = 0 ;
49396 PyObject * obj1 = 0 ;
49397 char * kwnames[] = {
49398 (char *) "self",(char *) "other", NULL
49399 };
49400
49401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49403 if (!SWIG_IsOK(res1)) {
49404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49405 }
49406 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49407 arg2 = obj1;
49408 {
49409 result = (bool)wxGBPosition___eq__(arg1,arg2);
49410 if (PyErr_Occurred()) SWIG_fail;
49411 }
49412 {
49413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49414 }
49415 return resultobj;
49416 fail:
49417 return NULL;
49418 }
49419
49420
49421 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49422 PyObject *resultobj = 0;
49423 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49424 PyObject *arg2 = (PyObject *) 0 ;
49425 bool result;
49426 void *argp1 = 0 ;
49427 int res1 = 0 ;
49428 PyObject * obj0 = 0 ;
49429 PyObject * obj1 = 0 ;
49430 char * kwnames[] = {
49431 (char *) "self",(char *) "other", NULL
49432 };
49433
49434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49436 if (!SWIG_IsOK(res1)) {
49437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49438 }
49439 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49440 arg2 = obj1;
49441 {
49442 result = (bool)wxGBPosition___ne__(arg1,arg2);
49443 if (PyErr_Occurred()) SWIG_fail;
49444 }
49445 {
49446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49447 }
49448 return resultobj;
49449 fail:
49450 return NULL;
49451 }
49452
49453
49454 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49455 PyObject *resultobj = 0;
49456 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49457 int arg2 = (int) 0 ;
49458 int arg3 = (int) 0 ;
49459 void *argp1 = 0 ;
49460 int res1 = 0 ;
49461 int val2 ;
49462 int ecode2 = 0 ;
49463 int val3 ;
49464 int ecode3 = 0 ;
49465 PyObject * obj0 = 0 ;
49466 PyObject * obj1 = 0 ;
49467 PyObject * obj2 = 0 ;
49468 char * kwnames[] = {
49469 (char *) "self",(char *) "row",(char *) "col", NULL
49470 };
49471
49472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49474 if (!SWIG_IsOK(res1)) {
49475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49476 }
49477 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49478 if (obj1) {
49479 ecode2 = SWIG_AsVal_int(obj1, &val2);
49480 if (!SWIG_IsOK(ecode2)) {
49481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49482 }
49483 arg2 = static_cast< int >(val2);
49484 }
49485 if (obj2) {
49486 ecode3 = SWIG_AsVal_int(obj2, &val3);
49487 if (!SWIG_IsOK(ecode3)) {
49488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49489 }
49490 arg3 = static_cast< int >(val3);
49491 }
49492 {
49493 PyThreadState* __tstate = wxPyBeginAllowThreads();
49494 wxGBPosition_Set(arg1,arg2,arg3);
49495 wxPyEndAllowThreads(__tstate);
49496 if (PyErr_Occurred()) SWIG_fail;
49497 }
49498 resultobj = SWIG_Py_Void();
49499 return resultobj;
49500 fail:
49501 return NULL;
49502 }
49503
49504
49505 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49506 PyObject *resultobj = 0;
49507 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49508 PyObject *result = 0 ;
49509 void *argp1 = 0 ;
49510 int res1 = 0 ;
49511 PyObject *swig_obj[1] ;
49512
49513 if (!args) SWIG_fail;
49514 swig_obj[0] = args;
49515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49516 if (!SWIG_IsOK(res1)) {
49517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49518 }
49519 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49520 {
49521 PyThreadState* __tstate = wxPyBeginAllowThreads();
49522 result = (PyObject *)wxGBPosition_Get(arg1);
49523 wxPyEndAllowThreads(__tstate);
49524 if (PyErr_Occurred()) SWIG_fail;
49525 }
49526 resultobj = result;
49527 return resultobj;
49528 fail:
49529 return NULL;
49530 }
49531
49532
49533 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49534 PyObject *obj;
49535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49536 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49537 return SWIG_Py_Void();
49538 }
49539
49540 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49541 return SWIG_Python_InitShadowInstance(args);
49542 }
49543
49544 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49545 PyObject *resultobj = 0;
49546 int arg1 = (int) 1 ;
49547 int arg2 = (int) 1 ;
49548 wxGBSpan *result = 0 ;
49549 int val1 ;
49550 int ecode1 = 0 ;
49551 int val2 ;
49552 int ecode2 = 0 ;
49553 PyObject * obj0 = 0 ;
49554 PyObject * obj1 = 0 ;
49555 char * kwnames[] = {
49556 (char *) "rowspan",(char *) "colspan", NULL
49557 };
49558
49559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49560 if (obj0) {
49561 ecode1 = SWIG_AsVal_int(obj0, &val1);
49562 if (!SWIG_IsOK(ecode1)) {
49563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49564 }
49565 arg1 = static_cast< int >(val1);
49566 }
49567 if (obj1) {
49568 ecode2 = SWIG_AsVal_int(obj1, &val2);
49569 if (!SWIG_IsOK(ecode2)) {
49570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49571 }
49572 arg2 = static_cast< int >(val2);
49573 }
49574 {
49575 PyThreadState* __tstate = wxPyBeginAllowThreads();
49576 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49577 wxPyEndAllowThreads(__tstate);
49578 if (PyErr_Occurred()) SWIG_fail;
49579 }
49580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49581 return resultobj;
49582 fail:
49583 return NULL;
49584 }
49585
49586
49587 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49588 PyObject *resultobj = 0;
49589 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49590 void *argp1 = 0 ;
49591 int res1 = 0 ;
49592 PyObject *swig_obj[1] ;
49593
49594 if (!args) SWIG_fail;
49595 swig_obj[0] = args;
49596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49597 if (!SWIG_IsOK(res1)) {
49598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49599 }
49600 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49601 {
49602 PyThreadState* __tstate = wxPyBeginAllowThreads();
49603 delete arg1;
49604
49605 wxPyEndAllowThreads(__tstate);
49606 if (PyErr_Occurred()) SWIG_fail;
49607 }
49608 resultobj = SWIG_Py_Void();
49609 return resultobj;
49610 fail:
49611 return NULL;
49612 }
49613
49614
49615 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49616 PyObject *resultobj = 0;
49617 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49618 int result;
49619 void *argp1 = 0 ;
49620 int res1 = 0 ;
49621 PyObject *swig_obj[1] ;
49622
49623 if (!args) SWIG_fail;
49624 swig_obj[0] = args;
49625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49626 if (!SWIG_IsOK(res1)) {
49627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49628 }
49629 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49630 {
49631 PyThreadState* __tstate = wxPyBeginAllowThreads();
49632 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49633 wxPyEndAllowThreads(__tstate);
49634 if (PyErr_Occurred()) SWIG_fail;
49635 }
49636 resultobj = SWIG_From_int(static_cast< int >(result));
49637 return resultobj;
49638 fail:
49639 return NULL;
49640 }
49641
49642
49643 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49644 PyObject *resultobj = 0;
49645 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49646 int result;
49647 void *argp1 = 0 ;
49648 int res1 = 0 ;
49649 PyObject *swig_obj[1] ;
49650
49651 if (!args) SWIG_fail;
49652 swig_obj[0] = args;
49653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49654 if (!SWIG_IsOK(res1)) {
49655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49656 }
49657 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49658 {
49659 PyThreadState* __tstate = wxPyBeginAllowThreads();
49660 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49661 wxPyEndAllowThreads(__tstate);
49662 if (PyErr_Occurred()) SWIG_fail;
49663 }
49664 resultobj = SWIG_From_int(static_cast< int >(result));
49665 return resultobj;
49666 fail:
49667 return NULL;
49668 }
49669
49670
49671 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49672 PyObject *resultobj = 0;
49673 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49674 int arg2 ;
49675 void *argp1 = 0 ;
49676 int res1 = 0 ;
49677 int val2 ;
49678 int ecode2 = 0 ;
49679 PyObject * obj0 = 0 ;
49680 PyObject * obj1 = 0 ;
49681 char * kwnames[] = {
49682 (char *) "self",(char *) "rowspan", NULL
49683 };
49684
49685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49687 if (!SWIG_IsOK(res1)) {
49688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49689 }
49690 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49691 ecode2 = SWIG_AsVal_int(obj1, &val2);
49692 if (!SWIG_IsOK(ecode2)) {
49693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49694 }
49695 arg2 = static_cast< int >(val2);
49696 {
49697 PyThreadState* __tstate = wxPyBeginAllowThreads();
49698 (arg1)->SetRowspan(arg2);
49699 wxPyEndAllowThreads(__tstate);
49700 if (PyErr_Occurred()) SWIG_fail;
49701 }
49702 resultobj = SWIG_Py_Void();
49703 return resultobj;
49704 fail:
49705 return NULL;
49706 }
49707
49708
49709 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49710 PyObject *resultobj = 0;
49711 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49712 int arg2 ;
49713 void *argp1 = 0 ;
49714 int res1 = 0 ;
49715 int val2 ;
49716 int ecode2 = 0 ;
49717 PyObject * obj0 = 0 ;
49718 PyObject * obj1 = 0 ;
49719 char * kwnames[] = {
49720 (char *) "self",(char *) "colspan", NULL
49721 };
49722
49723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49725 if (!SWIG_IsOK(res1)) {
49726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49727 }
49728 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49729 ecode2 = SWIG_AsVal_int(obj1, &val2);
49730 if (!SWIG_IsOK(ecode2)) {
49731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49732 }
49733 arg2 = static_cast< int >(val2);
49734 {
49735 PyThreadState* __tstate = wxPyBeginAllowThreads();
49736 (arg1)->SetColspan(arg2);
49737 wxPyEndAllowThreads(__tstate);
49738 if (PyErr_Occurred()) SWIG_fail;
49739 }
49740 resultobj = SWIG_Py_Void();
49741 return resultobj;
49742 fail:
49743 return NULL;
49744 }
49745
49746
49747 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49748 PyObject *resultobj = 0;
49749 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49750 PyObject *arg2 = (PyObject *) 0 ;
49751 bool result;
49752 void *argp1 = 0 ;
49753 int res1 = 0 ;
49754 PyObject * obj0 = 0 ;
49755 PyObject * obj1 = 0 ;
49756 char * kwnames[] = {
49757 (char *) "self",(char *) "other", NULL
49758 };
49759
49760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49762 if (!SWIG_IsOK(res1)) {
49763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49764 }
49765 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49766 arg2 = obj1;
49767 {
49768 result = (bool)wxGBSpan___eq__(arg1,arg2);
49769 if (PyErr_Occurred()) SWIG_fail;
49770 }
49771 {
49772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49773 }
49774 return resultobj;
49775 fail:
49776 return NULL;
49777 }
49778
49779
49780 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49781 PyObject *resultobj = 0;
49782 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49783 PyObject *arg2 = (PyObject *) 0 ;
49784 bool result;
49785 void *argp1 = 0 ;
49786 int res1 = 0 ;
49787 PyObject * obj0 = 0 ;
49788 PyObject * obj1 = 0 ;
49789 char * kwnames[] = {
49790 (char *) "self",(char *) "other", NULL
49791 };
49792
49793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49795 if (!SWIG_IsOK(res1)) {
49796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49797 }
49798 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49799 arg2 = obj1;
49800 {
49801 result = (bool)wxGBSpan___ne__(arg1,arg2);
49802 if (PyErr_Occurred()) SWIG_fail;
49803 }
49804 {
49805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49806 }
49807 return resultobj;
49808 fail:
49809 return NULL;
49810 }
49811
49812
49813 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49814 PyObject *resultobj = 0;
49815 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49816 int arg2 = (int) 1 ;
49817 int arg3 = (int) 1 ;
49818 void *argp1 = 0 ;
49819 int res1 = 0 ;
49820 int val2 ;
49821 int ecode2 = 0 ;
49822 int val3 ;
49823 int ecode3 = 0 ;
49824 PyObject * obj0 = 0 ;
49825 PyObject * obj1 = 0 ;
49826 PyObject * obj2 = 0 ;
49827 char * kwnames[] = {
49828 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49829 };
49830
49831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49833 if (!SWIG_IsOK(res1)) {
49834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49835 }
49836 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49837 if (obj1) {
49838 ecode2 = SWIG_AsVal_int(obj1, &val2);
49839 if (!SWIG_IsOK(ecode2)) {
49840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49841 }
49842 arg2 = static_cast< int >(val2);
49843 }
49844 if (obj2) {
49845 ecode3 = SWIG_AsVal_int(obj2, &val3);
49846 if (!SWIG_IsOK(ecode3)) {
49847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49848 }
49849 arg3 = static_cast< int >(val3);
49850 }
49851 {
49852 PyThreadState* __tstate = wxPyBeginAllowThreads();
49853 wxGBSpan_Set(arg1,arg2,arg3);
49854 wxPyEndAllowThreads(__tstate);
49855 if (PyErr_Occurred()) SWIG_fail;
49856 }
49857 resultobj = SWIG_Py_Void();
49858 return resultobj;
49859 fail:
49860 return NULL;
49861 }
49862
49863
49864 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49865 PyObject *resultobj = 0;
49866 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49867 PyObject *result = 0 ;
49868 void *argp1 = 0 ;
49869 int res1 = 0 ;
49870 PyObject *swig_obj[1] ;
49871
49872 if (!args) SWIG_fail;
49873 swig_obj[0] = args;
49874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49875 if (!SWIG_IsOK(res1)) {
49876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49877 }
49878 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49879 {
49880 PyThreadState* __tstate = wxPyBeginAllowThreads();
49881 result = (PyObject *)wxGBSpan_Get(arg1);
49882 wxPyEndAllowThreads(__tstate);
49883 if (PyErr_Occurred()) SWIG_fail;
49884 }
49885 resultobj = result;
49886 return resultobj;
49887 fail:
49888 return NULL;
49889 }
49890
49891
49892 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49893 PyObject *obj;
49894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49895 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49896 return SWIG_Py_Void();
49897 }
49898
49899 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49900 return SWIG_Python_InitShadowInstance(args);
49901 }
49902
49903 SWIGINTERN int DefaultSpan_set(PyObject *) {
49904 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49905 return 1;
49906 }
49907
49908
49909 SWIGINTERN PyObject *DefaultSpan_get(void) {
49910 PyObject *pyobj = 0;
49911
49912 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49913 return pyobj;
49914 }
49915
49916
49917 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49918 PyObject *resultobj = 0;
49919 wxGBSizerItem *result = 0 ;
49920
49921 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49922 {
49923 PyThreadState* __tstate = wxPyBeginAllowThreads();
49924 result = (wxGBSizerItem *)new wxGBSizerItem();
49925 wxPyEndAllowThreads(__tstate);
49926 if (PyErr_Occurred()) SWIG_fail;
49927 }
49928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49929 return resultobj;
49930 fail:
49931 return NULL;
49932 }
49933
49934
49935 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49936 PyObject *resultobj = 0;
49937 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49938 void *argp1 = 0 ;
49939 int res1 = 0 ;
49940 PyObject *swig_obj[1] ;
49941
49942 if (!args) SWIG_fail;
49943 swig_obj[0] = args;
49944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49945 if (!SWIG_IsOK(res1)) {
49946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49947 }
49948 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49949 {
49950 PyThreadState* __tstate = wxPyBeginAllowThreads();
49951 delete arg1;
49952
49953 wxPyEndAllowThreads(__tstate);
49954 if (PyErr_Occurred()) SWIG_fail;
49955 }
49956 resultobj = SWIG_Py_Void();
49957 return resultobj;
49958 fail:
49959 return NULL;
49960 }
49961
49962
49963 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49964 PyObject *resultobj = 0;
49965 wxWindow *arg1 = (wxWindow *) 0 ;
49966 wxGBPosition *arg2 = 0 ;
49967 wxGBSpan *arg3 = 0 ;
49968 int arg4 ;
49969 int arg5 ;
49970 PyObject *arg6 = (PyObject *) NULL ;
49971 wxGBSizerItem *result = 0 ;
49972 void *argp1 = 0 ;
49973 int res1 = 0 ;
49974 wxGBPosition temp2 ;
49975 wxGBSpan temp3 ;
49976 int val4 ;
49977 int ecode4 = 0 ;
49978 int val5 ;
49979 int ecode5 = 0 ;
49980 PyObject * obj0 = 0 ;
49981 PyObject * obj1 = 0 ;
49982 PyObject * obj2 = 0 ;
49983 PyObject * obj3 = 0 ;
49984 PyObject * obj4 = 0 ;
49985 PyObject * obj5 = 0 ;
49986 char * kwnames[] = {
49987 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49988 };
49989
49990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49992 if (!SWIG_IsOK(res1)) {
49993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49994 }
49995 arg1 = reinterpret_cast< wxWindow * >(argp1);
49996 {
49997 arg2 = &temp2;
49998 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49999 }
50000 {
50001 arg3 = &temp3;
50002 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50003 }
50004 ecode4 = SWIG_AsVal_int(obj3, &val4);
50005 if (!SWIG_IsOK(ecode4)) {
50006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50007 }
50008 arg4 = static_cast< int >(val4);
50009 ecode5 = SWIG_AsVal_int(obj4, &val5);
50010 if (!SWIG_IsOK(ecode5)) {
50011 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50012 }
50013 arg5 = static_cast< int >(val5);
50014 if (obj5) {
50015 arg6 = obj5;
50016 }
50017 {
50018 PyThreadState* __tstate = wxPyBeginAllowThreads();
50019 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50020 wxPyEndAllowThreads(__tstate);
50021 if (PyErr_Occurred()) SWIG_fail;
50022 }
50023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50024 return resultobj;
50025 fail:
50026 return NULL;
50027 }
50028
50029
50030 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50031 PyObject *resultobj = 0;
50032 wxSizer *arg1 = (wxSizer *) 0 ;
50033 wxGBPosition *arg2 = 0 ;
50034 wxGBSpan *arg3 = 0 ;
50035 int arg4 ;
50036 int arg5 ;
50037 PyObject *arg6 = (PyObject *) NULL ;
50038 wxGBSizerItem *result = 0 ;
50039 int res1 = 0 ;
50040 wxGBPosition temp2 ;
50041 wxGBSpan temp3 ;
50042 int val4 ;
50043 int ecode4 = 0 ;
50044 int val5 ;
50045 int ecode5 = 0 ;
50046 PyObject * obj0 = 0 ;
50047 PyObject * obj1 = 0 ;
50048 PyObject * obj2 = 0 ;
50049 PyObject * obj3 = 0 ;
50050 PyObject * obj4 = 0 ;
50051 PyObject * obj5 = 0 ;
50052 char * kwnames[] = {
50053 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50054 };
50055
50056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50057 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50058 if (!SWIG_IsOK(res1)) {
50059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50060 }
50061 {
50062 arg2 = &temp2;
50063 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50064 }
50065 {
50066 arg3 = &temp3;
50067 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50068 }
50069 ecode4 = SWIG_AsVal_int(obj3, &val4);
50070 if (!SWIG_IsOK(ecode4)) {
50071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50072 }
50073 arg4 = static_cast< int >(val4);
50074 ecode5 = SWIG_AsVal_int(obj4, &val5);
50075 if (!SWIG_IsOK(ecode5)) {
50076 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50077 }
50078 arg5 = static_cast< int >(val5);
50079 if (obj5) {
50080 arg6 = obj5;
50081 }
50082 {
50083 PyThreadState* __tstate = wxPyBeginAllowThreads();
50084 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50085 wxPyEndAllowThreads(__tstate);
50086 if (PyErr_Occurred()) SWIG_fail;
50087 }
50088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50089 return resultobj;
50090 fail:
50091 return NULL;
50092 }
50093
50094
50095 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50096 PyObject *resultobj = 0;
50097 int arg1 ;
50098 int arg2 ;
50099 wxGBPosition *arg3 = 0 ;
50100 wxGBSpan *arg4 = 0 ;
50101 int arg5 ;
50102 int arg6 ;
50103 PyObject *arg7 = (PyObject *) NULL ;
50104 wxGBSizerItem *result = 0 ;
50105 int val1 ;
50106 int ecode1 = 0 ;
50107 int val2 ;
50108 int ecode2 = 0 ;
50109 wxGBPosition temp3 ;
50110 wxGBSpan temp4 ;
50111 int val5 ;
50112 int ecode5 = 0 ;
50113 int val6 ;
50114 int ecode6 = 0 ;
50115 PyObject * obj0 = 0 ;
50116 PyObject * obj1 = 0 ;
50117 PyObject * obj2 = 0 ;
50118 PyObject * obj3 = 0 ;
50119 PyObject * obj4 = 0 ;
50120 PyObject * obj5 = 0 ;
50121 PyObject * obj6 = 0 ;
50122 char * kwnames[] = {
50123 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50124 };
50125
50126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50127 ecode1 = SWIG_AsVal_int(obj0, &val1);
50128 if (!SWIG_IsOK(ecode1)) {
50129 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50130 }
50131 arg1 = static_cast< int >(val1);
50132 ecode2 = SWIG_AsVal_int(obj1, &val2);
50133 if (!SWIG_IsOK(ecode2)) {
50134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50135 }
50136 arg2 = static_cast< int >(val2);
50137 {
50138 arg3 = &temp3;
50139 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50140 }
50141 {
50142 arg4 = &temp4;
50143 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50144 }
50145 ecode5 = SWIG_AsVal_int(obj4, &val5);
50146 if (!SWIG_IsOK(ecode5)) {
50147 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50148 }
50149 arg5 = static_cast< int >(val5);
50150 ecode6 = SWIG_AsVal_int(obj5, &val6);
50151 if (!SWIG_IsOK(ecode6)) {
50152 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50153 }
50154 arg6 = static_cast< int >(val6);
50155 if (obj6) {
50156 arg7 = obj6;
50157 }
50158 {
50159 PyThreadState* __tstate = wxPyBeginAllowThreads();
50160 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50161 wxPyEndAllowThreads(__tstate);
50162 if (PyErr_Occurred()) SWIG_fail;
50163 }
50164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50165 return resultobj;
50166 fail:
50167 return NULL;
50168 }
50169
50170
50171 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50172 PyObject *resultobj = 0;
50173 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50174 wxGBPosition result;
50175 void *argp1 = 0 ;
50176 int res1 = 0 ;
50177 PyObject *swig_obj[1] ;
50178
50179 if (!args) SWIG_fail;
50180 swig_obj[0] = args;
50181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50182 if (!SWIG_IsOK(res1)) {
50183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50184 }
50185 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50186 {
50187 PyThreadState* __tstate = wxPyBeginAllowThreads();
50188 result = ((wxGBSizerItem const *)arg1)->GetPos();
50189 wxPyEndAllowThreads(__tstate);
50190 if (PyErr_Occurred()) SWIG_fail;
50191 }
50192 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50193 return resultobj;
50194 fail:
50195 return NULL;
50196 }
50197
50198
50199 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50200 PyObject *resultobj = 0;
50201 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50202 wxGBSpan result;
50203 void *argp1 = 0 ;
50204 int res1 = 0 ;
50205 PyObject *swig_obj[1] ;
50206
50207 if (!args) SWIG_fail;
50208 swig_obj[0] = args;
50209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50210 if (!SWIG_IsOK(res1)) {
50211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50212 }
50213 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50214 {
50215 PyThreadState* __tstate = wxPyBeginAllowThreads();
50216 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50217 wxPyEndAllowThreads(__tstate);
50218 if (PyErr_Occurred()) SWIG_fail;
50219 }
50220 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50221 return resultobj;
50222 fail:
50223 return NULL;
50224 }
50225
50226
50227 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50228 PyObject *resultobj = 0;
50229 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50230 wxGBPosition *arg2 = 0 ;
50231 bool result;
50232 void *argp1 = 0 ;
50233 int res1 = 0 ;
50234 wxGBPosition temp2 ;
50235 PyObject * obj0 = 0 ;
50236 PyObject * obj1 = 0 ;
50237 char * kwnames[] = {
50238 (char *) "self",(char *) "pos", NULL
50239 };
50240
50241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50243 if (!SWIG_IsOK(res1)) {
50244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50245 }
50246 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50247 {
50248 arg2 = &temp2;
50249 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50250 }
50251 {
50252 PyThreadState* __tstate = wxPyBeginAllowThreads();
50253 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50254 wxPyEndAllowThreads(__tstate);
50255 if (PyErr_Occurred()) SWIG_fail;
50256 }
50257 {
50258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50259 }
50260 return resultobj;
50261 fail:
50262 return NULL;
50263 }
50264
50265
50266 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50267 PyObject *resultobj = 0;
50268 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50269 wxGBSpan *arg2 = 0 ;
50270 bool result;
50271 void *argp1 = 0 ;
50272 int res1 = 0 ;
50273 wxGBSpan temp2 ;
50274 PyObject * obj0 = 0 ;
50275 PyObject * obj1 = 0 ;
50276 char * kwnames[] = {
50277 (char *) "self",(char *) "span", NULL
50278 };
50279
50280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50282 if (!SWIG_IsOK(res1)) {
50283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50284 }
50285 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50286 {
50287 arg2 = &temp2;
50288 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50289 }
50290 {
50291 PyThreadState* __tstate = wxPyBeginAllowThreads();
50292 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50293 wxPyEndAllowThreads(__tstate);
50294 if (PyErr_Occurred()) SWIG_fail;
50295 }
50296 {
50297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50298 }
50299 return resultobj;
50300 fail:
50301 return NULL;
50302 }
50303
50304
50305 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50306 PyObject *resultobj = 0;
50307 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50308 wxGBSizerItem *arg2 = 0 ;
50309 bool result;
50310 void *argp1 = 0 ;
50311 int res1 = 0 ;
50312 void *argp2 = 0 ;
50313 int res2 = 0 ;
50314 PyObject * obj0 = 0 ;
50315 PyObject * obj1 = 0 ;
50316 char * kwnames[] = {
50317 (char *) "self",(char *) "other", NULL
50318 };
50319
50320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50322 if (!SWIG_IsOK(res1)) {
50323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50324 }
50325 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50326 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50327 if (!SWIG_IsOK(res2)) {
50328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50329 }
50330 if (!argp2) {
50331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50332 }
50333 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50334 {
50335 PyThreadState* __tstate = wxPyBeginAllowThreads();
50336 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50337 wxPyEndAllowThreads(__tstate);
50338 if (PyErr_Occurred()) SWIG_fail;
50339 }
50340 {
50341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50342 }
50343 return resultobj;
50344 fail:
50345 return NULL;
50346 }
50347
50348
50349 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50350 PyObject *resultobj = 0;
50351 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50352 wxGBPosition *arg2 = 0 ;
50353 wxGBSpan *arg3 = 0 ;
50354 bool result;
50355 void *argp1 = 0 ;
50356 int res1 = 0 ;
50357 wxGBPosition temp2 ;
50358 wxGBSpan temp3 ;
50359 PyObject * obj0 = 0 ;
50360 PyObject * obj1 = 0 ;
50361 PyObject * obj2 = 0 ;
50362 char * kwnames[] = {
50363 (char *) "self",(char *) "pos",(char *) "span", NULL
50364 };
50365
50366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50368 if (!SWIG_IsOK(res1)) {
50369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50370 }
50371 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50372 {
50373 arg2 = &temp2;
50374 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50375 }
50376 {
50377 arg3 = &temp3;
50378 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50379 }
50380 {
50381 PyThreadState* __tstate = wxPyBeginAllowThreads();
50382 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50383 wxPyEndAllowThreads(__tstate);
50384 if (PyErr_Occurred()) SWIG_fail;
50385 }
50386 {
50387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50388 }
50389 return resultobj;
50390 fail:
50391 return NULL;
50392 }
50393
50394
50395 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50396 PyObject *resultobj = 0;
50397 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50398 wxGBPosition result;
50399 void *argp1 = 0 ;
50400 int res1 = 0 ;
50401 PyObject *swig_obj[1] ;
50402
50403 if (!args) SWIG_fail;
50404 swig_obj[0] = args;
50405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50406 if (!SWIG_IsOK(res1)) {
50407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50408 }
50409 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50410 {
50411 PyThreadState* __tstate = wxPyBeginAllowThreads();
50412 result = wxGBSizerItem_GetEndPos(arg1);
50413 wxPyEndAllowThreads(__tstate);
50414 if (PyErr_Occurred()) SWIG_fail;
50415 }
50416 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50417 return resultobj;
50418 fail:
50419 return NULL;
50420 }
50421
50422
50423 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50424 PyObject *resultobj = 0;
50425 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50426 wxGridBagSizer *result = 0 ;
50427 void *argp1 = 0 ;
50428 int res1 = 0 ;
50429 PyObject *swig_obj[1] ;
50430
50431 if (!args) SWIG_fail;
50432 swig_obj[0] = args;
50433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50434 if (!SWIG_IsOK(res1)) {
50435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50436 }
50437 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50438 {
50439 PyThreadState* __tstate = wxPyBeginAllowThreads();
50440 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50441 wxPyEndAllowThreads(__tstate);
50442 if (PyErr_Occurred()) SWIG_fail;
50443 }
50444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50445 return resultobj;
50446 fail:
50447 return NULL;
50448 }
50449
50450
50451 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50452 PyObject *resultobj = 0;
50453 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50454 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50455 void *argp1 = 0 ;
50456 int res1 = 0 ;
50457 void *argp2 = 0 ;
50458 int res2 = 0 ;
50459 PyObject * obj0 = 0 ;
50460 PyObject * obj1 = 0 ;
50461 char * kwnames[] = {
50462 (char *) "self",(char *) "sizer", NULL
50463 };
50464
50465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50467 if (!SWIG_IsOK(res1)) {
50468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50469 }
50470 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50472 if (!SWIG_IsOK(res2)) {
50473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50474 }
50475 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50476 {
50477 PyThreadState* __tstate = wxPyBeginAllowThreads();
50478 (arg1)->SetGBSizer(arg2);
50479 wxPyEndAllowThreads(__tstate);
50480 if (PyErr_Occurred()) SWIG_fail;
50481 }
50482 resultobj = SWIG_Py_Void();
50483 return resultobj;
50484 fail:
50485 return NULL;
50486 }
50487
50488
50489 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50490 PyObject *obj;
50491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50492 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50493 return SWIG_Py_Void();
50494 }
50495
50496 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50497 return SWIG_Python_InitShadowInstance(args);
50498 }
50499
50500 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50501 PyObject *resultobj = 0;
50502 int arg1 = (int) 0 ;
50503 int arg2 = (int) 0 ;
50504 wxGridBagSizer *result = 0 ;
50505 int val1 ;
50506 int ecode1 = 0 ;
50507 int val2 ;
50508 int ecode2 = 0 ;
50509 PyObject * obj0 = 0 ;
50510 PyObject * obj1 = 0 ;
50511 char * kwnames[] = {
50512 (char *) "vgap",(char *) "hgap", NULL
50513 };
50514
50515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50516 if (obj0) {
50517 ecode1 = SWIG_AsVal_int(obj0, &val1);
50518 if (!SWIG_IsOK(ecode1)) {
50519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50520 }
50521 arg1 = static_cast< int >(val1);
50522 }
50523 if (obj1) {
50524 ecode2 = SWIG_AsVal_int(obj1, &val2);
50525 if (!SWIG_IsOK(ecode2)) {
50526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50527 }
50528 arg2 = static_cast< int >(val2);
50529 }
50530 {
50531 PyThreadState* __tstate = wxPyBeginAllowThreads();
50532 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50533 wxPyEndAllowThreads(__tstate);
50534 if (PyErr_Occurred()) SWIG_fail;
50535 }
50536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50537 return resultobj;
50538 fail:
50539 return NULL;
50540 }
50541
50542
50543 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50544 PyObject *resultobj = 0;
50545 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50546 PyObject *arg2 = (PyObject *) 0 ;
50547 wxGBPosition *arg3 = 0 ;
50548 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50549 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50550 int arg5 = (int) 0 ;
50551 int arg6 = (int) 0 ;
50552 PyObject *arg7 = (PyObject *) NULL ;
50553 wxGBSizerItem *result = 0 ;
50554 void *argp1 = 0 ;
50555 int res1 = 0 ;
50556 wxGBPosition temp3 ;
50557 wxGBSpan temp4 ;
50558 int val5 ;
50559 int ecode5 = 0 ;
50560 int val6 ;
50561 int ecode6 = 0 ;
50562 PyObject * obj0 = 0 ;
50563 PyObject * obj1 = 0 ;
50564 PyObject * obj2 = 0 ;
50565 PyObject * obj3 = 0 ;
50566 PyObject * obj4 = 0 ;
50567 PyObject * obj5 = 0 ;
50568 PyObject * obj6 = 0 ;
50569 char * kwnames[] = {
50570 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50571 };
50572
50573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50575 if (!SWIG_IsOK(res1)) {
50576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50577 }
50578 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50579 arg2 = obj1;
50580 {
50581 arg3 = &temp3;
50582 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50583 }
50584 if (obj3) {
50585 {
50586 arg4 = &temp4;
50587 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50588 }
50589 }
50590 if (obj4) {
50591 ecode5 = SWIG_AsVal_int(obj4, &val5);
50592 if (!SWIG_IsOK(ecode5)) {
50593 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50594 }
50595 arg5 = static_cast< int >(val5);
50596 }
50597 if (obj5) {
50598 ecode6 = SWIG_AsVal_int(obj5, &val6);
50599 if (!SWIG_IsOK(ecode6)) {
50600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50601 }
50602 arg6 = static_cast< int >(val6);
50603 }
50604 if (obj6) {
50605 arg7 = obj6;
50606 }
50607 {
50608 PyThreadState* __tstate = wxPyBeginAllowThreads();
50609 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50610 wxPyEndAllowThreads(__tstate);
50611 if (PyErr_Occurred()) SWIG_fail;
50612 }
50613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50614 return resultobj;
50615 fail:
50616 return NULL;
50617 }
50618
50619
50620 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50621 PyObject *resultobj = 0;
50622 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50623 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50624 wxGBSizerItem *result = 0 ;
50625 void *argp1 = 0 ;
50626 int res1 = 0 ;
50627 int res2 = 0 ;
50628 PyObject * obj0 = 0 ;
50629 PyObject * obj1 = 0 ;
50630 char * kwnames[] = {
50631 (char *) "self",(char *) "item", NULL
50632 };
50633
50634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50636 if (!SWIG_IsOK(res1)) {
50637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50638 }
50639 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50640 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50641 if (!SWIG_IsOK(res2)) {
50642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50643 }
50644 {
50645 PyThreadState* __tstate = wxPyBeginAllowThreads();
50646 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50647 wxPyEndAllowThreads(__tstate);
50648 if (PyErr_Occurred()) SWIG_fail;
50649 }
50650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50651 return resultobj;
50652 fail:
50653 return NULL;
50654 }
50655
50656
50657 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50658 PyObject *resultobj = 0;
50659 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50660 int arg2 ;
50661 int arg3 ;
50662 wxSize result;
50663 void *argp1 = 0 ;
50664 int res1 = 0 ;
50665 int val2 ;
50666 int ecode2 = 0 ;
50667 int val3 ;
50668 int ecode3 = 0 ;
50669 PyObject * obj0 = 0 ;
50670 PyObject * obj1 = 0 ;
50671 PyObject * obj2 = 0 ;
50672 char * kwnames[] = {
50673 (char *) "self",(char *) "row",(char *) "col", NULL
50674 };
50675
50676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50678 if (!SWIG_IsOK(res1)) {
50679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50680 }
50681 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50682 ecode2 = SWIG_AsVal_int(obj1, &val2);
50683 if (!SWIG_IsOK(ecode2)) {
50684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50685 }
50686 arg2 = static_cast< int >(val2);
50687 ecode3 = SWIG_AsVal_int(obj2, &val3);
50688 if (!SWIG_IsOK(ecode3)) {
50689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50690 }
50691 arg3 = static_cast< int >(val3);
50692 {
50693 PyThreadState* __tstate = wxPyBeginAllowThreads();
50694 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50695 wxPyEndAllowThreads(__tstate);
50696 if (PyErr_Occurred()) SWIG_fail;
50697 }
50698 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50699 return resultobj;
50700 fail:
50701 return NULL;
50702 }
50703
50704
50705 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50706 PyObject *resultobj = 0;
50707 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50708 wxSize result;
50709 void *argp1 = 0 ;
50710 int res1 = 0 ;
50711 PyObject *swig_obj[1] ;
50712
50713 if (!args) SWIG_fail;
50714 swig_obj[0] = args;
50715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50716 if (!SWIG_IsOK(res1)) {
50717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50718 }
50719 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50720 {
50721 PyThreadState* __tstate = wxPyBeginAllowThreads();
50722 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50723 wxPyEndAllowThreads(__tstate);
50724 if (PyErr_Occurred()) SWIG_fail;
50725 }
50726 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50727 return resultobj;
50728 fail:
50729 return NULL;
50730 }
50731
50732
50733 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50734 PyObject *resultobj = 0;
50735 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50736 wxSize *arg2 = 0 ;
50737 void *argp1 = 0 ;
50738 int res1 = 0 ;
50739 wxSize temp2 ;
50740 PyObject * obj0 = 0 ;
50741 PyObject * obj1 = 0 ;
50742 char * kwnames[] = {
50743 (char *) "self",(char *) "sz", NULL
50744 };
50745
50746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50748 if (!SWIG_IsOK(res1)) {
50749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50750 }
50751 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50752 {
50753 arg2 = &temp2;
50754 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50755 }
50756 {
50757 PyThreadState* __tstate = wxPyBeginAllowThreads();
50758 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50759 wxPyEndAllowThreads(__tstate);
50760 if (PyErr_Occurred()) SWIG_fail;
50761 }
50762 resultobj = SWIG_Py_Void();
50763 return resultobj;
50764 fail:
50765 return NULL;
50766 }
50767
50768
50769 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50770 PyObject *resultobj = 0;
50771 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50772 wxWindow *arg2 = (wxWindow *) 0 ;
50773 wxGBPosition result;
50774 void *argp1 = 0 ;
50775 int res1 = 0 ;
50776 void *argp2 = 0 ;
50777 int res2 = 0 ;
50778
50779 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50781 if (!SWIG_IsOK(res1)) {
50782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50783 }
50784 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50785 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50786 if (!SWIG_IsOK(res2)) {
50787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50788 }
50789 arg2 = reinterpret_cast< wxWindow * >(argp2);
50790 {
50791 PyThreadState* __tstate = wxPyBeginAllowThreads();
50792 result = (arg1)->GetItemPosition(arg2);
50793 wxPyEndAllowThreads(__tstate);
50794 if (PyErr_Occurred()) SWIG_fail;
50795 }
50796 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50797 return resultobj;
50798 fail:
50799 return NULL;
50800 }
50801
50802
50803 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50804 PyObject *resultobj = 0;
50805 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50806 wxSizer *arg2 = (wxSizer *) 0 ;
50807 wxGBPosition result;
50808 void *argp1 = 0 ;
50809 int res1 = 0 ;
50810 void *argp2 = 0 ;
50811 int res2 = 0 ;
50812
50813 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50815 if (!SWIG_IsOK(res1)) {
50816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50817 }
50818 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50819 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50820 if (!SWIG_IsOK(res2)) {
50821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50822 }
50823 arg2 = reinterpret_cast< wxSizer * >(argp2);
50824 {
50825 PyThreadState* __tstate = wxPyBeginAllowThreads();
50826 result = (arg1)->GetItemPosition(arg2);
50827 wxPyEndAllowThreads(__tstate);
50828 if (PyErr_Occurred()) SWIG_fail;
50829 }
50830 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50831 return resultobj;
50832 fail:
50833 return NULL;
50834 }
50835
50836
50837 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50838 PyObject *resultobj = 0;
50839 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50840 size_t arg2 ;
50841 wxGBPosition result;
50842 void *argp1 = 0 ;
50843 int res1 = 0 ;
50844 size_t val2 ;
50845 int ecode2 = 0 ;
50846
50847 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50849 if (!SWIG_IsOK(res1)) {
50850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50851 }
50852 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50853 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50854 if (!SWIG_IsOK(ecode2)) {
50855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50856 }
50857 arg2 = static_cast< size_t >(val2);
50858 {
50859 PyThreadState* __tstate = wxPyBeginAllowThreads();
50860 result = (arg1)->GetItemPosition(arg2);
50861 wxPyEndAllowThreads(__tstate);
50862 if (PyErr_Occurred()) SWIG_fail;
50863 }
50864 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50865 return resultobj;
50866 fail:
50867 return NULL;
50868 }
50869
50870
50871 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50872 int argc;
50873 PyObject *argv[3];
50874
50875 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50876 --argc;
50877 if (argc == 2) {
50878 int _v = 0;
50879 {
50880 void *vptr = 0;
50881 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50882 _v = SWIG_CheckState(res);
50883 }
50884 if (!_v) goto check_1;
50885 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50886 }
50887 check_1:
50888
50889 if (argc == 2) {
50890 int _v = 0;
50891 {
50892 void *vptr = 0;
50893 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50894 _v = SWIG_CheckState(res);
50895 }
50896 if (!_v) goto check_2;
50897 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50898 }
50899 check_2:
50900
50901 if (argc == 2) {
50902 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50903 }
50904
50905 fail:
50906 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50907 return NULL;
50908 }
50909
50910
50911 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50912 PyObject *resultobj = 0;
50913 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50914 wxWindow *arg2 = (wxWindow *) 0 ;
50915 wxGBPosition *arg3 = 0 ;
50916 bool result;
50917 void *argp1 = 0 ;
50918 int res1 = 0 ;
50919 void *argp2 = 0 ;
50920 int res2 = 0 ;
50921 wxGBPosition temp3 ;
50922
50923 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50925 if (!SWIG_IsOK(res1)) {
50926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50927 }
50928 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50929 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50930 if (!SWIG_IsOK(res2)) {
50931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50932 }
50933 arg2 = reinterpret_cast< wxWindow * >(argp2);
50934 {
50935 arg3 = &temp3;
50936 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50937 }
50938 {
50939 PyThreadState* __tstate = wxPyBeginAllowThreads();
50940 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50941 wxPyEndAllowThreads(__tstate);
50942 if (PyErr_Occurred()) SWIG_fail;
50943 }
50944 {
50945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50946 }
50947 return resultobj;
50948 fail:
50949 return NULL;
50950 }
50951
50952
50953 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50954 PyObject *resultobj = 0;
50955 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50956 wxSizer *arg2 = (wxSizer *) 0 ;
50957 wxGBPosition *arg3 = 0 ;
50958 bool result;
50959 void *argp1 = 0 ;
50960 int res1 = 0 ;
50961 void *argp2 = 0 ;
50962 int res2 = 0 ;
50963 wxGBPosition temp3 ;
50964
50965 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50967 if (!SWIG_IsOK(res1)) {
50968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50969 }
50970 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50971 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50972 if (!SWIG_IsOK(res2)) {
50973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50974 }
50975 arg2 = reinterpret_cast< wxSizer * >(argp2);
50976 {
50977 arg3 = &temp3;
50978 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50979 }
50980 {
50981 PyThreadState* __tstate = wxPyBeginAllowThreads();
50982 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50983 wxPyEndAllowThreads(__tstate);
50984 if (PyErr_Occurred()) SWIG_fail;
50985 }
50986 {
50987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50988 }
50989 return resultobj;
50990 fail:
50991 return NULL;
50992 }
50993
50994
50995 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50996 PyObject *resultobj = 0;
50997 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50998 size_t arg2 ;
50999 wxGBPosition *arg3 = 0 ;
51000 bool result;
51001 void *argp1 = 0 ;
51002 int res1 = 0 ;
51003 size_t val2 ;
51004 int ecode2 = 0 ;
51005 wxGBPosition temp3 ;
51006
51007 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51009 if (!SWIG_IsOK(res1)) {
51010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51011 }
51012 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51013 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51014 if (!SWIG_IsOK(ecode2)) {
51015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51016 }
51017 arg2 = static_cast< size_t >(val2);
51018 {
51019 arg3 = &temp3;
51020 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51021 }
51022 {
51023 PyThreadState* __tstate = wxPyBeginAllowThreads();
51024 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51025 wxPyEndAllowThreads(__tstate);
51026 if (PyErr_Occurred()) SWIG_fail;
51027 }
51028 {
51029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51030 }
51031 return resultobj;
51032 fail:
51033 return NULL;
51034 }
51035
51036
51037 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51038 int argc;
51039 PyObject *argv[4];
51040
51041 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51042 --argc;
51043 if (argc == 3) {
51044 int _v = 0;
51045 {
51046 void *vptr = 0;
51047 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51048 _v = SWIG_CheckState(res);
51049 }
51050 if (!_v) goto check_1;
51051 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51052 }
51053 check_1:
51054
51055 if (argc == 3) {
51056 int _v = 0;
51057 {
51058 void *vptr = 0;
51059 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51060 _v = SWIG_CheckState(res);
51061 }
51062 if (!_v) goto check_2;
51063 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51064 }
51065 check_2:
51066
51067 if (argc == 3) {
51068 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51069 }
51070
51071 fail:
51072 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51073 return NULL;
51074 }
51075
51076
51077 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51078 PyObject *resultobj = 0;
51079 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51080 wxWindow *arg2 = (wxWindow *) 0 ;
51081 wxGBSpan result;
51082 void *argp1 = 0 ;
51083 int res1 = 0 ;
51084 void *argp2 = 0 ;
51085 int res2 = 0 ;
51086
51087 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51089 if (!SWIG_IsOK(res1)) {
51090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51091 }
51092 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51093 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51094 if (!SWIG_IsOK(res2)) {
51095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51096 }
51097 arg2 = reinterpret_cast< wxWindow * >(argp2);
51098 {
51099 PyThreadState* __tstate = wxPyBeginAllowThreads();
51100 result = (arg1)->GetItemSpan(arg2);
51101 wxPyEndAllowThreads(__tstate);
51102 if (PyErr_Occurred()) SWIG_fail;
51103 }
51104 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51105 return resultobj;
51106 fail:
51107 return NULL;
51108 }
51109
51110
51111 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51112 PyObject *resultobj = 0;
51113 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51114 wxSizer *arg2 = (wxSizer *) 0 ;
51115 wxGBSpan result;
51116 void *argp1 = 0 ;
51117 int res1 = 0 ;
51118 void *argp2 = 0 ;
51119 int res2 = 0 ;
51120
51121 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51123 if (!SWIG_IsOK(res1)) {
51124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51125 }
51126 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51127 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51128 if (!SWIG_IsOK(res2)) {
51129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51130 }
51131 arg2 = reinterpret_cast< wxSizer * >(argp2);
51132 {
51133 PyThreadState* __tstate = wxPyBeginAllowThreads();
51134 result = (arg1)->GetItemSpan(arg2);
51135 wxPyEndAllowThreads(__tstate);
51136 if (PyErr_Occurred()) SWIG_fail;
51137 }
51138 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51139 return resultobj;
51140 fail:
51141 return NULL;
51142 }
51143
51144
51145 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51146 PyObject *resultobj = 0;
51147 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51148 size_t arg2 ;
51149 wxGBSpan result;
51150 void *argp1 = 0 ;
51151 int res1 = 0 ;
51152 size_t val2 ;
51153 int ecode2 = 0 ;
51154
51155 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51157 if (!SWIG_IsOK(res1)) {
51158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51159 }
51160 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51161 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51162 if (!SWIG_IsOK(ecode2)) {
51163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51164 }
51165 arg2 = static_cast< size_t >(val2);
51166 {
51167 PyThreadState* __tstate = wxPyBeginAllowThreads();
51168 result = (arg1)->GetItemSpan(arg2);
51169 wxPyEndAllowThreads(__tstate);
51170 if (PyErr_Occurred()) SWIG_fail;
51171 }
51172 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51173 return resultobj;
51174 fail:
51175 return NULL;
51176 }
51177
51178
51179 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51180 int argc;
51181 PyObject *argv[3];
51182
51183 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51184 --argc;
51185 if (argc == 2) {
51186 int _v = 0;
51187 {
51188 void *vptr = 0;
51189 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51190 _v = SWIG_CheckState(res);
51191 }
51192 if (!_v) goto check_1;
51193 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51194 }
51195 check_1:
51196
51197 if (argc == 2) {
51198 int _v = 0;
51199 {
51200 void *vptr = 0;
51201 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51202 _v = SWIG_CheckState(res);
51203 }
51204 if (!_v) goto check_2;
51205 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51206 }
51207 check_2:
51208
51209 if (argc == 2) {
51210 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51211 }
51212
51213 fail:
51214 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51215 return NULL;
51216 }
51217
51218
51219 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51220 PyObject *resultobj = 0;
51221 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51222 wxWindow *arg2 = (wxWindow *) 0 ;
51223 wxGBSpan *arg3 = 0 ;
51224 bool result;
51225 void *argp1 = 0 ;
51226 int res1 = 0 ;
51227 void *argp2 = 0 ;
51228 int res2 = 0 ;
51229 wxGBSpan temp3 ;
51230
51231 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51233 if (!SWIG_IsOK(res1)) {
51234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51235 }
51236 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51237 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51238 if (!SWIG_IsOK(res2)) {
51239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51240 }
51241 arg2 = reinterpret_cast< wxWindow * >(argp2);
51242 {
51243 arg3 = &temp3;
51244 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51245 }
51246 {
51247 PyThreadState* __tstate = wxPyBeginAllowThreads();
51248 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51249 wxPyEndAllowThreads(__tstate);
51250 if (PyErr_Occurred()) SWIG_fail;
51251 }
51252 {
51253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51254 }
51255 return resultobj;
51256 fail:
51257 return NULL;
51258 }
51259
51260
51261 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51262 PyObject *resultobj = 0;
51263 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51264 wxSizer *arg2 = (wxSizer *) 0 ;
51265 wxGBSpan *arg3 = 0 ;
51266 bool result;
51267 void *argp1 = 0 ;
51268 int res1 = 0 ;
51269 void *argp2 = 0 ;
51270 int res2 = 0 ;
51271 wxGBSpan temp3 ;
51272
51273 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51275 if (!SWIG_IsOK(res1)) {
51276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51277 }
51278 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51279 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51280 if (!SWIG_IsOK(res2)) {
51281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51282 }
51283 arg2 = reinterpret_cast< wxSizer * >(argp2);
51284 {
51285 arg3 = &temp3;
51286 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51287 }
51288 {
51289 PyThreadState* __tstate = wxPyBeginAllowThreads();
51290 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51291 wxPyEndAllowThreads(__tstate);
51292 if (PyErr_Occurred()) SWIG_fail;
51293 }
51294 {
51295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51296 }
51297 return resultobj;
51298 fail:
51299 return NULL;
51300 }
51301
51302
51303 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51304 PyObject *resultobj = 0;
51305 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51306 size_t arg2 ;
51307 wxGBSpan *arg3 = 0 ;
51308 bool result;
51309 void *argp1 = 0 ;
51310 int res1 = 0 ;
51311 size_t val2 ;
51312 int ecode2 = 0 ;
51313 wxGBSpan temp3 ;
51314
51315 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51317 if (!SWIG_IsOK(res1)) {
51318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51319 }
51320 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51321 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51322 if (!SWIG_IsOK(ecode2)) {
51323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51324 }
51325 arg2 = static_cast< size_t >(val2);
51326 {
51327 arg3 = &temp3;
51328 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51329 }
51330 {
51331 PyThreadState* __tstate = wxPyBeginAllowThreads();
51332 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51333 wxPyEndAllowThreads(__tstate);
51334 if (PyErr_Occurred()) SWIG_fail;
51335 }
51336 {
51337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51338 }
51339 return resultobj;
51340 fail:
51341 return NULL;
51342 }
51343
51344
51345 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51346 int argc;
51347 PyObject *argv[4];
51348
51349 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51350 --argc;
51351 if (argc == 3) {
51352 int _v = 0;
51353 {
51354 void *vptr = 0;
51355 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51356 _v = SWIG_CheckState(res);
51357 }
51358 if (!_v) goto check_1;
51359 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51360 }
51361 check_1:
51362
51363 if (argc == 3) {
51364 int _v = 0;
51365 {
51366 void *vptr = 0;
51367 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51368 _v = SWIG_CheckState(res);
51369 }
51370 if (!_v) goto check_2;
51371 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51372 }
51373 check_2:
51374
51375 if (argc == 3) {
51376 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51377 }
51378
51379 fail:
51380 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51381 return NULL;
51382 }
51383
51384
51385 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51386 PyObject *resultobj = 0;
51387 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51388 wxWindow *arg2 = (wxWindow *) 0 ;
51389 wxGBSizerItem *result = 0 ;
51390 void *argp1 = 0 ;
51391 int res1 = 0 ;
51392 void *argp2 = 0 ;
51393 int res2 = 0 ;
51394
51395 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51397 if (!SWIG_IsOK(res1)) {
51398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51399 }
51400 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51401 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51402 if (!SWIG_IsOK(res2)) {
51403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51404 }
51405 arg2 = reinterpret_cast< wxWindow * >(argp2);
51406 {
51407 PyThreadState* __tstate = wxPyBeginAllowThreads();
51408 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51409 wxPyEndAllowThreads(__tstate);
51410 if (PyErr_Occurred()) SWIG_fail;
51411 }
51412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51413 return resultobj;
51414 fail:
51415 return NULL;
51416 }
51417
51418
51419 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51420 PyObject *resultobj = 0;
51421 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51422 wxSizer *arg2 = (wxSizer *) 0 ;
51423 wxGBSizerItem *result = 0 ;
51424 void *argp1 = 0 ;
51425 int res1 = 0 ;
51426 void *argp2 = 0 ;
51427 int res2 = 0 ;
51428
51429 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51431 if (!SWIG_IsOK(res1)) {
51432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51433 }
51434 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51435 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51436 if (!SWIG_IsOK(res2)) {
51437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51438 }
51439 arg2 = reinterpret_cast< wxSizer * >(argp2);
51440 {
51441 PyThreadState* __tstate = wxPyBeginAllowThreads();
51442 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51443 wxPyEndAllowThreads(__tstate);
51444 if (PyErr_Occurred()) SWIG_fail;
51445 }
51446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51447 return resultobj;
51448 fail:
51449 return NULL;
51450 }
51451
51452
51453 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51454 int argc;
51455 PyObject *argv[3];
51456
51457 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51458 --argc;
51459 if (argc == 2) {
51460 int _v = 0;
51461 {
51462 void *vptr = 0;
51463 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51464 _v = SWIG_CheckState(res);
51465 }
51466 if (!_v) goto check_1;
51467 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51468 }
51469 check_1:
51470
51471 if (argc == 2) {
51472 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51473 }
51474
51475 fail:
51476 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51477 return NULL;
51478 }
51479
51480
51481 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51482 PyObject *resultobj = 0;
51483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51484 wxGBPosition *arg2 = 0 ;
51485 wxGBSizerItem *result = 0 ;
51486 void *argp1 = 0 ;
51487 int res1 = 0 ;
51488 wxGBPosition temp2 ;
51489 PyObject * obj0 = 0 ;
51490 PyObject * obj1 = 0 ;
51491 char * kwnames[] = {
51492 (char *) "self",(char *) "pos", NULL
51493 };
51494
51495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51497 if (!SWIG_IsOK(res1)) {
51498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51499 }
51500 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51501 {
51502 arg2 = &temp2;
51503 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51504 }
51505 {
51506 PyThreadState* __tstate = wxPyBeginAllowThreads();
51507 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51508 wxPyEndAllowThreads(__tstate);
51509 if (PyErr_Occurred()) SWIG_fail;
51510 }
51511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51512 return resultobj;
51513 fail:
51514 return NULL;
51515 }
51516
51517
51518 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51519 PyObject *resultobj = 0;
51520 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51521 wxPoint *arg2 = 0 ;
51522 wxGBSizerItem *result = 0 ;
51523 void *argp1 = 0 ;
51524 int res1 = 0 ;
51525 wxPoint temp2 ;
51526 PyObject * obj0 = 0 ;
51527 PyObject * obj1 = 0 ;
51528 char * kwnames[] = {
51529 (char *) "self",(char *) "pt", NULL
51530 };
51531
51532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51534 if (!SWIG_IsOK(res1)) {
51535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51536 }
51537 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51538 {
51539 arg2 = &temp2;
51540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51541 }
51542 {
51543 PyThreadState* __tstate = wxPyBeginAllowThreads();
51544 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51545 wxPyEndAllowThreads(__tstate);
51546 if (PyErr_Occurred()) SWIG_fail;
51547 }
51548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51549 return resultobj;
51550 fail:
51551 return NULL;
51552 }
51553
51554
51555 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51556 PyObject *resultobj = 0;
51557 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51558 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51559 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51560 bool result;
51561 void *argp1 = 0 ;
51562 int res1 = 0 ;
51563 void *argp2 = 0 ;
51564 int res2 = 0 ;
51565 void *argp3 = 0 ;
51566 int res3 = 0 ;
51567 PyObject * obj0 = 0 ;
51568 PyObject * obj1 = 0 ;
51569 PyObject * obj2 = 0 ;
51570 char * kwnames[] = {
51571 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51572 };
51573
51574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51576 if (!SWIG_IsOK(res1)) {
51577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51578 }
51579 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51580 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51581 if (!SWIG_IsOK(res2)) {
51582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51583 }
51584 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51585 if (obj2) {
51586 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51587 if (!SWIG_IsOK(res3)) {
51588 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51589 }
51590 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51591 }
51592 {
51593 PyThreadState* __tstate = wxPyBeginAllowThreads();
51594 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51595 wxPyEndAllowThreads(__tstate);
51596 if (PyErr_Occurred()) SWIG_fail;
51597 }
51598 {
51599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51600 }
51601 return resultobj;
51602 fail:
51603 return NULL;
51604 }
51605
51606
51607 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51608 PyObject *resultobj = 0;
51609 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51610 wxGBPosition *arg2 = 0 ;
51611 wxGBSpan *arg3 = 0 ;
51612 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51613 bool result;
51614 void *argp1 = 0 ;
51615 int res1 = 0 ;
51616 wxGBPosition temp2 ;
51617 wxGBSpan temp3 ;
51618 void *argp4 = 0 ;
51619 int res4 = 0 ;
51620 PyObject * obj0 = 0 ;
51621 PyObject * obj1 = 0 ;
51622 PyObject * obj2 = 0 ;
51623 PyObject * obj3 = 0 ;
51624 char * kwnames[] = {
51625 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51626 };
51627
51628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51630 if (!SWIG_IsOK(res1)) {
51631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51632 }
51633 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51634 {
51635 arg2 = &temp2;
51636 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51637 }
51638 {
51639 arg3 = &temp3;
51640 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51641 }
51642 if (obj3) {
51643 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51644 if (!SWIG_IsOK(res4)) {
51645 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51646 }
51647 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51648 }
51649 {
51650 PyThreadState* __tstate = wxPyBeginAllowThreads();
51651 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51652 wxPyEndAllowThreads(__tstate);
51653 if (PyErr_Occurred()) SWIG_fail;
51654 }
51655 {
51656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51657 }
51658 return resultobj;
51659 fail:
51660 return NULL;
51661 }
51662
51663
51664 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51665 PyObject *obj;
51666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51667 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51668 return SWIG_Py_Void();
51669 }
51670
51671 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51672 return SWIG_Python_InitShadowInstance(args);
51673 }
51674
51675 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51676 PyObject *resultobj = 0;
51677 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51678 wxRelationship arg2 ;
51679 wxWindow *arg3 = (wxWindow *) 0 ;
51680 wxEdge arg4 ;
51681 int arg5 = (int) 0 ;
51682 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51683 void *argp1 = 0 ;
51684 int res1 = 0 ;
51685 int val2 ;
51686 int ecode2 = 0 ;
51687 void *argp3 = 0 ;
51688 int res3 = 0 ;
51689 int val4 ;
51690 int ecode4 = 0 ;
51691 int val5 ;
51692 int ecode5 = 0 ;
51693 int val6 ;
51694 int ecode6 = 0 ;
51695 PyObject * obj0 = 0 ;
51696 PyObject * obj1 = 0 ;
51697 PyObject * obj2 = 0 ;
51698 PyObject * obj3 = 0 ;
51699 PyObject * obj4 = 0 ;
51700 PyObject * obj5 = 0 ;
51701 char * kwnames[] = {
51702 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51703 };
51704
51705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51707 if (!SWIG_IsOK(res1)) {
51708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51709 }
51710 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51711 ecode2 = SWIG_AsVal_int(obj1, &val2);
51712 if (!SWIG_IsOK(ecode2)) {
51713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51714 }
51715 arg2 = static_cast< wxRelationship >(val2);
51716 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51717 if (!SWIG_IsOK(res3)) {
51718 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51719 }
51720 arg3 = reinterpret_cast< wxWindow * >(argp3);
51721 ecode4 = SWIG_AsVal_int(obj3, &val4);
51722 if (!SWIG_IsOK(ecode4)) {
51723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51724 }
51725 arg4 = static_cast< wxEdge >(val4);
51726 if (obj4) {
51727 ecode5 = SWIG_AsVal_int(obj4, &val5);
51728 if (!SWIG_IsOK(ecode5)) {
51729 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51730 }
51731 arg5 = static_cast< int >(val5);
51732 }
51733 if (obj5) {
51734 ecode6 = SWIG_AsVal_int(obj5, &val6);
51735 if (!SWIG_IsOK(ecode6)) {
51736 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51737 }
51738 arg6 = static_cast< int >(val6);
51739 }
51740 {
51741 PyThreadState* __tstate = wxPyBeginAllowThreads();
51742 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51743 wxPyEndAllowThreads(__tstate);
51744 if (PyErr_Occurred()) SWIG_fail;
51745 }
51746 resultobj = SWIG_Py_Void();
51747 return resultobj;
51748 fail:
51749 return NULL;
51750 }
51751
51752
51753 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51754 PyObject *resultobj = 0;
51755 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51756 wxWindow *arg2 = (wxWindow *) 0 ;
51757 int arg3 = (int) 0 ;
51758 void *argp1 = 0 ;
51759 int res1 = 0 ;
51760 void *argp2 = 0 ;
51761 int res2 = 0 ;
51762 int val3 ;
51763 int ecode3 = 0 ;
51764 PyObject * obj0 = 0 ;
51765 PyObject * obj1 = 0 ;
51766 PyObject * obj2 = 0 ;
51767 char * kwnames[] = {
51768 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51769 };
51770
51771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51773 if (!SWIG_IsOK(res1)) {
51774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51775 }
51776 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51778 if (!SWIG_IsOK(res2)) {
51779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51780 }
51781 arg2 = reinterpret_cast< wxWindow * >(argp2);
51782 if (obj2) {
51783 ecode3 = SWIG_AsVal_int(obj2, &val3);
51784 if (!SWIG_IsOK(ecode3)) {
51785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51786 }
51787 arg3 = static_cast< int >(val3);
51788 }
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 (arg1)->LeftOf(arg2,arg3);
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_Py_Void();
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51803 PyObject *resultobj = 0;
51804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51805 wxWindow *arg2 = (wxWindow *) 0 ;
51806 int arg3 = (int) 0 ;
51807 void *argp1 = 0 ;
51808 int res1 = 0 ;
51809 void *argp2 = 0 ;
51810 int res2 = 0 ;
51811 int val3 ;
51812 int ecode3 = 0 ;
51813 PyObject * obj0 = 0 ;
51814 PyObject * obj1 = 0 ;
51815 PyObject * obj2 = 0 ;
51816 char * kwnames[] = {
51817 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51818 };
51819
51820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51822 if (!SWIG_IsOK(res1)) {
51823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51824 }
51825 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51826 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51827 if (!SWIG_IsOK(res2)) {
51828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51829 }
51830 arg2 = reinterpret_cast< wxWindow * >(argp2);
51831 if (obj2) {
51832 ecode3 = SWIG_AsVal_int(obj2, &val3);
51833 if (!SWIG_IsOK(ecode3)) {
51834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51835 }
51836 arg3 = static_cast< int >(val3);
51837 }
51838 {
51839 PyThreadState* __tstate = wxPyBeginAllowThreads();
51840 (arg1)->RightOf(arg2,arg3);
51841 wxPyEndAllowThreads(__tstate);
51842 if (PyErr_Occurred()) SWIG_fail;
51843 }
51844 resultobj = SWIG_Py_Void();
51845 return resultobj;
51846 fail:
51847 return NULL;
51848 }
51849
51850
51851 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51852 PyObject *resultobj = 0;
51853 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51854 wxWindow *arg2 = (wxWindow *) 0 ;
51855 int arg3 = (int) 0 ;
51856 void *argp1 = 0 ;
51857 int res1 = 0 ;
51858 void *argp2 = 0 ;
51859 int res2 = 0 ;
51860 int val3 ;
51861 int ecode3 = 0 ;
51862 PyObject * obj0 = 0 ;
51863 PyObject * obj1 = 0 ;
51864 PyObject * obj2 = 0 ;
51865 char * kwnames[] = {
51866 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51867 };
51868
51869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51871 if (!SWIG_IsOK(res1)) {
51872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51873 }
51874 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51876 if (!SWIG_IsOK(res2)) {
51877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51878 }
51879 arg2 = reinterpret_cast< wxWindow * >(argp2);
51880 if (obj2) {
51881 ecode3 = SWIG_AsVal_int(obj2, &val3);
51882 if (!SWIG_IsOK(ecode3)) {
51883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51884 }
51885 arg3 = static_cast< int >(val3);
51886 }
51887 {
51888 PyThreadState* __tstate = wxPyBeginAllowThreads();
51889 (arg1)->Above(arg2,arg3);
51890 wxPyEndAllowThreads(__tstate);
51891 if (PyErr_Occurred()) SWIG_fail;
51892 }
51893 resultobj = SWIG_Py_Void();
51894 return resultobj;
51895 fail:
51896 return NULL;
51897 }
51898
51899
51900 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51901 PyObject *resultobj = 0;
51902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51903 wxWindow *arg2 = (wxWindow *) 0 ;
51904 int arg3 = (int) 0 ;
51905 void *argp1 = 0 ;
51906 int res1 = 0 ;
51907 void *argp2 = 0 ;
51908 int res2 = 0 ;
51909 int val3 ;
51910 int ecode3 = 0 ;
51911 PyObject * obj0 = 0 ;
51912 PyObject * obj1 = 0 ;
51913 PyObject * obj2 = 0 ;
51914 char * kwnames[] = {
51915 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51916 };
51917
51918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51920 if (!SWIG_IsOK(res1)) {
51921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51922 }
51923 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51925 if (!SWIG_IsOK(res2)) {
51926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51927 }
51928 arg2 = reinterpret_cast< wxWindow * >(argp2);
51929 if (obj2) {
51930 ecode3 = SWIG_AsVal_int(obj2, &val3);
51931 if (!SWIG_IsOK(ecode3)) {
51932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51933 }
51934 arg3 = static_cast< int >(val3);
51935 }
51936 {
51937 PyThreadState* __tstate = wxPyBeginAllowThreads();
51938 (arg1)->Below(arg2,arg3);
51939 wxPyEndAllowThreads(__tstate);
51940 if (PyErr_Occurred()) SWIG_fail;
51941 }
51942 resultobj = SWIG_Py_Void();
51943 return resultobj;
51944 fail:
51945 return NULL;
51946 }
51947
51948
51949 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51950 PyObject *resultobj = 0;
51951 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51952 wxWindow *arg2 = (wxWindow *) 0 ;
51953 wxEdge arg3 ;
51954 int arg4 = (int) 0 ;
51955 void *argp1 = 0 ;
51956 int res1 = 0 ;
51957 void *argp2 = 0 ;
51958 int res2 = 0 ;
51959 int val3 ;
51960 int ecode3 = 0 ;
51961 int val4 ;
51962 int ecode4 = 0 ;
51963 PyObject * obj0 = 0 ;
51964 PyObject * obj1 = 0 ;
51965 PyObject * obj2 = 0 ;
51966 PyObject * obj3 = 0 ;
51967 char * kwnames[] = {
51968 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51969 };
51970
51971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51973 if (!SWIG_IsOK(res1)) {
51974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51975 }
51976 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51978 if (!SWIG_IsOK(res2)) {
51979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51980 }
51981 arg2 = reinterpret_cast< wxWindow * >(argp2);
51982 ecode3 = SWIG_AsVal_int(obj2, &val3);
51983 if (!SWIG_IsOK(ecode3)) {
51984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51985 }
51986 arg3 = static_cast< wxEdge >(val3);
51987 if (obj3) {
51988 ecode4 = SWIG_AsVal_int(obj3, &val4);
51989 if (!SWIG_IsOK(ecode4)) {
51990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51991 }
51992 arg4 = static_cast< int >(val4);
51993 }
51994 {
51995 PyThreadState* __tstate = wxPyBeginAllowThreads();
51996 (arg1)->SameAs(arg2,arg3,arg4);
51997 wxPyEndAllowThreads(__tstate);
51998 if (PyErr_Occurred()) SWIG_fail;
51999 }
52000 resultobj = SWIG_Py_Void();
52001 return resultobj;
52002 fail:
52003 return NULL;
52004 }
52005
52006
52007 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52008 PyObject *resultobj = 0;
52009 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52010 wxWindow *arg2 = (wxWindow *) 0 ;
52011 wxEdge arg3 ;
52012 int arg4 ;
52013 void *argp1 = 0 ;
52014 int res1 = 0 ;
52015 void *argp2 = 0 ;
52016 int res2 = 0 ;
52017 int val3 ;
52018 int ecode3 = 0 ;
52019 int val4 ;
52020 int ecode4 = 0 ;
52021 PyObject * obj0 = 0 ;
52022 PyObject * obj1 = 0 ;
52023 PyObject * obj2 = 0 ;
52024 PyObject * obj3 = 0 ;
52025 char * kwnames[] = {
52026 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52027 };
52028
52029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52031 if (!SWIG_IsOK(res1)) {
52032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52033 }
52034 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52036 if (!SWIG_IsOK(res2)) {
52037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52038 }
52039 arg2 = reinterpret_cast< wxWindow * >(argp2);
52040 ecode3 = SWIG_AsVal_int(obj2, &val3);
52041 if (!SWIG_IsOK(ecode3)) {
52042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52043 }
52044 arg3 = static_cast< wxEdge >(val3);
52045 ecode4 = SWIG_AsVal_int(obj3, &val4);
52046 if (!SWIG_IsOK(ecode4)) {
52047 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52048 }
52049 arg4 = static_cast< int >(val4);
52050 {
52051 PyThreadState* __tstate = wxPyBeginAllowThreads();
52052 (arg1)->PercentOf(arg2,arg3,arg4);
52053 wxPyEndAllowThreads(__tstate);
52054 if (PyErr_Occurred()) SWIG_fail;
52055 }
52056 resultobj = SWIG_Py_Void();
52057 return resultobj;
52058 fail:
52059 return NULL;
52060 }
52061
52062
52063 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52064 PyObject *resultobj = 0;
52065 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52066 int arg2 ;
52067 void *argp1 = 0 ;
52068 int res1 = 0 ;
52069 int val2 ;
52070 int ecode2 = 0 ;
52071 PyObject * obj0 = 0 ;
52072 PyObject * obj1 = 0 ;
52073 char * kwnames[] = {
52074 (char *) "self",(char *) "val", NULL
52075 };
52076
52077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52079 if (!SWIG_IsOK(res1)) {
52080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52081 }
52082 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52083 ecode2 = SWIG_AsVal_int(obj1, &val2);
52084 if (!SWIG_IsOK(ecode2)) {
52085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52086 }
52087 arg2 = static_cast< int >(val2);
52088 {
52089 PyThreadState* __tstate = wxPyBeginAllowThreads();
52090 (arg1)->Absolute(arg2);
52091 wxPyEndAllowThreads(__tstate);
52092 if (PyErr_Occurred()) SWIG_fail;
52093 }
52094 resultobj = SWIG_Py_Void();
52095 return resultobj;
52096 fail:
52097 return NULL;
52098 }
52099
52100
52101 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52102 PyObject *resultobj = 0;
52103 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52104 void *argp1 = 0 ;
52105 int res1 = 0 ;
52106 PyObject *swig_obj[1] ;
52107
52108 if (!args) SWIG_fail;
52109 swig_obj[0] = args;
52110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52111 if (!SWIG_IsOK(res1)) {
52112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52113 }
52114 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52115 {
52116 PyThreadState* __tstate = wxPyBeginAllowThreads();
52117 (arg1)->Unconstrained();
52118 wxPyEndAllowThreads(__tstate);
52119 if (PyErr_Occurred()) SWIG_fail;
52120 }
52121 resultobj = SWIG_Py_Void();
52122 return resultobj;
52123 fail:
52124 return NULL;
52125 }
52126
52127
52128 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52129 PyObject *resultobj = 0;
52130 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52131 void *argp1 = 0 ;
52132 int res1 = 0 ;
52133 PyObject *swig_obj[1] ;
52134
52135 if (!args) SWIG_fail;
52136 swig_obj[0] = args;
52137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52138 if (!SWIG_IsOK(res1)) {
52139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52140 }
52141 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52142 {
52143 PyThreadState* __tstate = wxPyBeginAllowThreads();
52144 (arg1)->AsIs();
52145 wxPyEndAllowThreads(__tstate);
52146 if (PyErr_Occurred()) SWIG_fail;
52147 }
52148 resultobj = SWIG_Py_Void();
52149 return resultobj;
52150 fail:
52151 return NULL;
52152 }
52153
52154
52155 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52156 PyObject *resultobj = 0;
52157 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52158 wxWindow *result = 0 ;
52159 void *argp1 = 0 ;
52160 int res1 = 0 ;
52161 PyObject *swig_obj[1] ;
52162
52163 if (!args) SWIG_fail;
52164 swig_obj[0] = args;
52165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52166 if (!SWIG_IsOK(res1)) {
52167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52168 }
52169 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52170 {
52171 PyThreadState* __tstate = wxPyBeginAllowThreads();
52172 result = (wxWindow *)(arg1)->GetOtherWindow();
52173 wxPyEndAllowThreads(__tstate);
52174 if (PyErr_Occurred()) SWIG_fail;
52175 }
52176 {
52177 resultobj = wxPyMake_wxObject(result, 0);
52178 }
52179 return resultobj;
52180 fail:
52181 return NULL;
52182 }
52183
52184
52185 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52186 PyObject *resultobj = 0;
52187 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52188 wxEdge result;
52189 void *argp1 = 0 ;
52190 int res1 = 0 ;
52191 PyObject *swig_obj[1] ;
52192
52193 if (!args) SWIG_fail;
52194 swig_obj[0] = args;
52195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52196 if (!SWIG_IsOK(res1)) {
52197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52198 }
52199 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52200 {
52201 PyThreadState* __tstate = wxPyBeginAllowThreads();
52202 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52203 wxPyEndAllowThreads(__tstate);
52204 if (PyErr_Occurred()) SWIG_fail;
52205 }
52206 resultobj = SWIG_From_int(static_cast< int >(result));
52207 return resultobj;
52208 fail:
52209 return NULL;
52210 }
52211
52212
52213 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52214 PyObject *resultobj = 0;
52215 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52216 wxEdge arg2 ;
52217 void *argp1 = 0 ;
52218 int res1 = 0 ;
52219 int val2 ;
52220 int ecode2 = 0 ;
52221 PyObject * obj0 = 0 ;
52222 PyObject * obj1 = 0 ;
52223 char * kwnames[] = {
52224 (char *) "self",(char *) "which", NULL
52225 };
52226
52227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52229 if (!SWIG_IsOK(res1)) {
52230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52231 }
52232 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52233 ecode2 = SWIG_AsVal_int(obj1, &val2);
52234 if (!SWIG_IsOK(ecode2)) {
52235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52236 }
52237 arg2 = static_cast< wxEdge >(val2);
52238 {
52239 PyThreadState* __tstate = wxPyBeginAllowThreads();
52240 (arg1)->SetEdge(arg2);
52241 wxPyEndAllowThreads(__tstate);
52242 if (PyErr_Occurred()) SWIG_fail;
52243 }
52244 resultobj = SWIG_Py_Void();
52245 return resultobj;
52246 fail:
52247 return NULL;
52248 }
52249
52250
52251 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52252 PyObject *resultobj = 0;
52253 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52254 int arg2 ;
52255 void *argp1 = 0 ;
52256 int res1 = 0 ;
52257 int val2 ;
52258 int ecode2 = 0 ;
52259 PyObject * obj0 = 0 ;
52260 PyObject * obj1 = 0 ;
52261 char * kwnames[] = {
52262 (char *) "self",(char *) "v", NULL
52263 };
52264
52265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52267 if (!SWIG_IsOK(res1)) {
52268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52269 }
52270 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52271 ecode2 = SWIG_AsVal_int(obj1, &val2);
52272 if (!SWIG_IsOK(ecode2)) {
52273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52274 }
52275 arg2 = static_cast< int >(val2);
52276 {
52277 PyThreadState* __tstate = wxPyBeginAllowThreads();
52278 (arg1)->SetValue(arg2);
52279 wxPyEndAllowThreads(__tstate);
52280 if (PyErr_Occurred()) SWIG_fail;
52281 }
52282 resultobj = SWIG_Py_Void();
52283 return resultobj;
52284 fail:
52285 return NULL;
52286 }
52287
52288
52289 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52290 PyObject *resultobj = 0;
52291 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52292 int result;
52293 void *argp1 = 0 ;
52294 int res1 = 0 ;
52295 PyObject *swig_obj[1] ;
52296
52297 if (!args) SWIG_fail;
52298 swig_obj[0] = args;
52299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52300 if (!SWIG_IsOK(res1)) {
52301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52302 }
52303 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52304 {
52305 PyThreadState* __tstate = wxPyBeginAllowThreads();
52306 result = (int)(arg1)->GetMargin();
52307 wxPyEndAllowThreads(__tstate);
52308 if (PyErr_Occurred()) SWIG_fail;
52309 }
52310 resultobj = SWIG_From_int(static_cast< int >(result));
52311 return resultobj;
52312 fail:
52313 return NULL;
52314 }
52315
52316
52317 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52318 PyObject *resultobj = 0;
52319 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52320 int arg2 ;
52321 void *argp1 = 0 ;
52322 int res1 = 0 ;
52323 int val2 ;
52324 int ecode2 = 0 ;
52325 PyObject * obj0 = 0 ;
52326 PyObject * obj1 = 0 ;
52327 char * kwnames[] = {
52328 (char *) "self",(char *) "m", NULL
52329 };
52330
52331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52333 if (!SWIG_IsOK(res1)) {
52334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52335 }
52336 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52337 ecode2 = SWIG_AsVal_int(obj1, &val2);
52338 if (!SWIG_IsOK(ecode2)) {
52339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52340 }
52341 arg2 = static_cast< int >(val2);
52342 {
52343 PyThreadState* __tstate = wxPyBeginAllowThreads();
52344 (arg1)->SetMargin(arg2);
52345 wxPyEndAllowThreads(__tstate);
52346 if (PyErr_Occurred()) SWIG_fail;
52347 }
52348 resultobj = SWIG_Py_Void();
52349 return resultobj;
52350 fail:
52351 return NULL;
52352 }
52353
52354
52355 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52356 PyObject *resultobj = 0;
52357 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52358 int result;
52359 void *argp1 = 0 ;
52360 int res1 = 0 ;
52361 PyObject *swig_obj[1] ;
52362
52363 if (!args) SWIG_fail;
52364 swig_obj[0] = args;
52365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52366 if (!SWIG_IsOK(res1)) {
52367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52368 }
52369 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52370 {
52371 PyThreadState* __tstate = wxPyBeginAllowThreads();
52372 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52373 wxPyEndAllowThreads(__tstate);
52374 if (PyErr_Occurred()) SWIG_fail;
52375 }
52376 resultobj = SWIG_From_int(static_cast< int >(result));
52377 return resultobj;
52378 fail:
52379 return NULL;
52380 }
52381
52382
52383 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52384 PyObject *resultobj = 0;
52385 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52386 int result;
52387 void *argp1 = 0 ;
52388 int res1 = 0 ;
52389 PyObject *swig_obj[1] ;
52390
52391 if (!args) SWIG_fail;
52392 swig_obj[0] = args;
52393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52394 if (!SWIG_IsOK(res1)) {
52395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52396 }
52397 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52398 {
52399 PyThreadState* __tstate = wxPyBeginAllowThreads();
52400 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52401 wxPyEndAllowThreads(__tstate);
52402 if (PyErr_Occurred()) SWIG_fail;
52403 }
52404 resultobj = SWIG_From_int(static_cast< int >(result));
52405 return resultobj;
52406 fail:
52407 return NULL;
52408 }
52409
52410
52411 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52412 PyObject *resultobj = 0;
52413 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52414 int result;
52415 void *argp1 = 0 ;
52416 int res1 = 0 ;
52417 PyObject *swig_obj[1] ;
52418
52419 if (!args) SWIG_fail;
52420 swig_obj[0] = args;
52421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52422 if (!SWIG_IsOK(res1)) {
52423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52424 }
52425 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52426 {
52427 PyThreadState* __tstate = wxPyBeginAllowThreads();
52428 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52429 wxPyEndAllowThreads(__tstate);
52430 if (PyErr_Occurred()) SWIG_fail;
52431 }
52432 resultobj = SWIG_From_int(static_cast< int >(result));
52433 return resultobj;
52434 fail:
52435 return NULL;
52436 }
52437
52438
52439 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52440 PyObject *resultobj = 0;
52441 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52442 bool result;
52443 void *argp1 = 0 ;
52444 int res1 = 0 ;
52445 PyObject *swig_obj[1] ;
52446
52447 if (!args) SWIG_fail;
52448 swig_obj[0] = args;
52449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52450 if (!SWIG_IsOK(res1)) {
52451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52452 }
52453 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52454 {
52455 PyThreadState* __tstate = wxPyBeginAllowThreads();
52456 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52457 wxPyEndAllowThreads(__tstate);
52458 if (PyErr_Occurred()) SWIG_fail;
52459 }
52460 {
52461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52462 }
52463 return resultobj;
52464 fail:
52465 return NULL;
52466 }
52467
52468
52469 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52470 PyObject *resultobj = 0;
52471 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52472 bool arg2 ;
52473 void *argp1 = 0 ;
52474 int res1 = 0 ;
52475 bool val2 ;
52476 int ecode2 = 0 ;
52477 PyObject * obj0 = 0 ;
52478 PyObject * obj1 = 0 ;
52479 char * kwnames[] = {
52480 (char *) "self",(char *) "d", NULL
52481 };
52482
52483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52485 if (!SWIG_IsOK(res1)) {
52486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52487 }
52488 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52489 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52490 if (!SWIG_IsOK(ecode2)) {
52491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52492 }
52493 arg2 = static_cast< bool >(val2);
52494 {
52495 PyThreadState* __tstate = wxPyBeginAllowThreads();
52496 (arg1)->SetDone(arg2);
52497 wxPyEndAllowThreads(__tstate);
52498 if (PyErr_Occurred()) SWIG_fail;
52499 }
52500 resultobj = SWIG_Py_Void();
52501 return resultobj;
52502 fail:
52503 return NULL;
52504 }
52505
52506
52507 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52508 PyObject *resultobj = 0;
52509 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52510 wxRelationship result;
52511 void *argp1 = 0 ;
52512 int res1 = 0 ;
52513 PyObject *swig_obj[1] ;
52514
52515 if (!args) SWIG_fail;
52516 swig_obj[0] = args;
52517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52518 if (!SWIG_IsOK(res1)) {
52519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52520 }
52521 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52522 {
52523 PyThreadState* __tstate = wxPyBeginAllowThreads();
52524 result = (wxRelationship)(arg1)->GetRelationship();
52525 wxPyEndAllowThreads(__tstate);
52526 if (PyErr_Occurred()) SWIG_fail;
52527 }
52528 resultobj = SWIG_From_int(static_cast< int >(result));
52529 return resultobj;
52530 fail:
52531 return NULL;
52532 }
52533
52534
52535 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52536 PyObject *resultobj = 0;
52537 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52538 wxRelationship arg2 ;
52539 void *argp1 = 0 ;
52540 int res1 = 0 ;
52541 int val2 ;
52542 int ecode2 = 0 ;
52543 PyObject * obj0 = 0 ;
52544 PyObject * obj1 = 0 ;
52545 char * kwnames[] = {
52546 (char *) "self",(char *) "r", NULL
52547 };
52548
52549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52551 if (!SWIG_IsOK(res1)) {
52552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52553 }
52554 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52555 ecode2 = SWIG_AsVal_int(obj1, &val2);
52556 if (!SWIG_IsOK(ecode2)) {
52557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52558 }
52559 arg2 = static_cast< wxRelationship >(val2);
52560 {
52561 PyThreadState* __tstate = wxPyBeginAllowThreads();
52562 (arg1)->SetRelationship(arg2);
52563 wxPyEndAllowThreads(__tstate);
52564 if (PyErr_Occurred()) SWIG_fail;
52565 }
52566 resultobj = SWIG_Py_Void();
52567 return resultobj;
52568 fail:
52569 return NULL;
52570 }
52571
52572
52573 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52574 PyObject *resultobj = 0;
52575 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52576 wxWindow *arg2 = (wxWindow *) 0 ;
52577 bool result;
52578 void *argp1 = 0 ;
52579 int res1 = 0 ;
52580 void *argp2 = 0 ;
52581 int res2 = 0 ;
52582 PyObject * obj0 = 0 ;
52583 PyObject * obj1 = 0 ;
52584 char * kwnames[] = {
52585 (char *) "self",(char *) "otherW", NULL
52586 };
52587
52588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52590 if (!SWIG_IsOK(res1)) {
52591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52592 }
52593 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52595 if (!SWIG_IsOK(res2)) {
52596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52597 }
52598 arg2 = reinterpret_cast< wxWindow * >(argp2);
52599 {
52600 PyThreadState* __tstate = wxPyBeginAllowThreads();
52601 result = (bool)(arg1)->ResetIfWin(arg2);
52602 wxPyEndAllowThreads(__tstate);
52603 if (PyErr_Occurred()) SWIG_fail;
52604 }
52605 {
52606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52607 }
52608 return resultobj;
52609 fail:
52610 return NULL;
52611 }
52612
52613
52614 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52615 PyObject *resultobj = 0;
52616 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52617 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52618 wxWindow *arg3 = (wxWindow *) 0 ;
52619 bool result;
52620 void *argp1 = 0 ;
52621 int res1 = 0 ;
52622 void *argp2 = 0 ;
52623 int res2 = 0 ;
52624 void *argp3 = 0 ;
52625 int res3 = 0 ;
52626 PyObject * obj0 = 0 ;
52627 PyObject * obj1 = 0 ;
52628 PyObject * obj2 = 0 ;
52629 char * kwnames[] = {
52630 (char *) "self",(char *) "constraints",(char *) "win", NULL
52631 };
52632
52633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52635 if (!SWIG_IsOK(res1)) {
52636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52637 }
52638 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52640 if (!SWIG_IsOK(res2)) {
52641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52642 }
52643 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52644 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52645 if (!SWIG_IsOK(res3)) {
52646 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52647 }
52648 arg3 = reinterpret_cast< wxWindow * >(argp3);
52649 {
52650 PyThreadState* __tstate = wxPyBeginAllowThreads();
52651 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52652 wxPyEndAllowThreads(__tstate);
52653 if (PyErr_Occurred()) SWIG_fail;
52654 }
52655 {
52656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52657 }
52658 return resultobj;
52659 fail:
52660 return NULL;
52661 }
52662
52663
52664 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52665 PyObject *resultobj = 0;
52666 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52667 wxEdge arg2 ;
52668 wxWindow *arg3 = (wxWindow *) 0 ;
52669 wxWindow *arg4 = (wxWindow *) 0 ;
52670 int result;
52671 void *argp1 = 0 ;
52672 int res1 = 0 ;
52673 int val2 ;
52674 int ecode2 = 0 ;
52675 void *argp3 = 0 ;
52676 int res3 = 0 ;
52677 void *argp4 = 0 ;
52678 int res4 = 0 ;
52679 PyObject * obj0 = 0 ;
52680 PyObject * obj1 = 0 ;
52681 PyObject * obj2 = 0 ;
52682 PyObject * obj3 = 0 ;
52683 char * kwnames[] = {
52684 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52685 };
52686
52687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52689 if (!SWIG_IsOK(res1)) {
52690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52691 }
52692 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52693 ecode2 = SWIG_AsVal_int(obj1, &val2);
52694 if (!SWIG_IsOK(ecode2)) {
52695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52696 }
52697 arg2 = static_cast< wxEdge >(val2);
52698 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52699 if (!SWIG_IsOK(res3)) {
52700 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52701 }
52702 arg3 = reinterpret_cast< wxWindow * >(argp3);
52703 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52704 if (!SWIG_IsOK(res4)) {
52705 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52706 }
52707 arg4 = reinterpret_cast< wxWindow * >(argp4);
52708 {
52709 PyThreadState* __tstate = wxPyBeginAllowThreads();
52710 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52711 wxPyEndAllowThreads(__tstate);
52712 if (PyErr_Occurred()) SWIG_fail;
52713 }
52714 resultobj = SWIG_From_int(static_cast< int >(result));
52715 return resultobj;
52716 fail:
52717 return NULL;
52718 }
52719
52720
52721 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52722 PyObject *obj;
52723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52724 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52725 return SWIG_Py_Void();
52726 }
52727
52728 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52729 PyObject *resultobj = 0;
52730 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52731 wxIndividualLayoutConstraint *result = 0 ;
52732 void *argp1 = 0 ;
52733 int res1 = 0 ;
52734 PyObject *swig_obj[1] ;
52735
52736 if (!args) SWIG_fail;
52737 swig_obj[0] = args;
52738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52739 if (!SWIG_IsOK(res1)) {
52740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52741 }
52742 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52743 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52745 return resultobj;
52746 fail:
52747 return NULL;
52748 }
52749
52750
52751 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52752 PyObject *resultobj = 0;
52753 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52754 wxIndividualLayoutConstraint *result = 0 ;
52755 void *argp1 = 0 ;
52756 int res1 = 0 ;
52757 PyObject *swig_obj[1] ;
52758
52759 if (!args) SWIG_fail;
52760 swig_obj[0] = args;
52761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52762 if (!SWIG_IsOK(res1)) {
52763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52764 }
52765 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52766 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52768 return resultobj;
52769 fail:
52770 return NULL;
52771 }
52772
52773
52774 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52775 PyObject *resultobj = 0;
52776 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52777 wxIndividualLayoutConstraint *result = 0 ;
52778 void *argp1 = 0 ;
52779 int res1 = 0 ;
52780 PyObject *swig_obj[1] ;
52781
52782 if (!args) SWIG_fail;
52783 swig_obj[0] = args;
52784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52785 if (!SWIG_IsOK(res1)) {
52786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52787 }
52788 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52789 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52791 return resultobj;
52792 fail:
52793 return NULL;
52794 }
52795
52796
52797 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52798 PyObject *resultobj = 0;
52799 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52800 wxIndividualLayoutConstraint *result = 0 ;
52801 void *argp1 = 0 ;
52802 int res1 = 0 ;
52803 PyObject *swig_obj[1] ;
52804
52805 if (!args) SWIG_fail;
52806 swig_obj[0] = args;
52807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52808 if (!SWIG_IsOK(res1)) {
52809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52810 }
52811 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52812 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52814 return resultobj;
52815 fail:
52816 return NULL;
52817 }
52818
52819
52820 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52821 PyObject *resultobj = 0;
52822 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52823 wxIndividualLayoutConstraint *result = 0 ;
52824 void *argp1 = 0 ;
52825 int res1 = 0 ;
52826 PyObject *swig_obj[1] ;
52827
52828 if (!args) SWIG_fail;
52829 swig_obj[0] = args;
52830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52831 if (!SWIG_IsOK(res1)) {
52832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52833 }
52834 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52835 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52837 return resultobj;
52838 fail:
52839 return NULL;
52840 }
52841
52842
52843 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52844 PyObject *resultobj = 0;
52845 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52846 wxIndividualLayoutConstraint *result = 0 ;
52847 void *argp1 = 0 ;
52848 int res1 = 0 ;
52849 PyObject *swig_obj[1] ;
52850
52851 if (!args) SWIG_fail;
52852 swig_obj[0] = args;
52853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52854 if (!SWIG_IsOK(res1)) {
52855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52856 }
52857 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52858 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52860 return resultobj;
52861 fail:
52862 return NULL;
52863 }
52864
52865
52866 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52867 PyObject *resultobj = 0;
52868 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52869 wxIndividualLayoutConstraint *result = 0 ;
52870 void *argp1 = 0 ;
52871 int res1 = 0 ;
52872 PyObject *swig_obj[1] ;
52873
52874 if (!args) SWIG_fail;
52875 swig_obj[0] = args;
52876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52877 if (!SWIG_IsOK(res1)) {
52878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52879 }
52880 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52881 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52883 return resultobj;
52884 fail:
52885 return NULL;
52886 }
52887
52888
52889 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52890 PyObject *resultobj = 0;
52891 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52892 wxIndividualLayoutConstraint *result = 0 ;
52893 void *argp1 = 0 ;
52894 int res1 = 0 ;
52895 PyObject *swig_obj[1] ;
52896
52897 if (!args) SWIG_fail;
52898 swig_obj[0] = args;
52899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52900 if (!SWIG_IsOK(res1)) {
52901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52902 }
52903 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52904 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52906 return resultobj;
52907 fail:
52908 return NULL;
52909 }
52910
52911
52912 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52913 PyObject *resultobj = 0;
52914 wxLayoutConstraints *result = 0 ;
52915
52916 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52917 {
52918 PyThreadState* __tstate = wxPyBeginAllowThreads();
52919 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52920 wxPyEndAllowThreads(__tstate);
52921 if (PyErr_Occurred()) SWIG_fail;
52922 }
52923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52924 return resultobj;
52925 fail:
52926 return NULL;
52927 }
52928
52929
52930 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52931 PyObject *resultobj = 0;
52932 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52933 void *argp1 = 0 ;
52934 int res1 = 0 ;
52935 PyObject *swig_obj[1] ;
52936
52937 if (!args) SWIG_fail;
52938 swig_obj[0] = args;
52939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52940 if (!SWIG_IsOK(res1)) {
52941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52942 }
52943 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52944 {
52945 PyThreadState* __tstate = wxPyBeginAllowThreads();
52946 delete arg1;
52947
52948 wxPyEndAllowThreads(__tstate);
52949 if (PyErr_Occurred()) SWIG_fail;
52950 }
52951 resultobj = SWIG_Py_Void();
52952 return resultobj;
52953 fail:
52954 return NULL;
52955 }
52956
52957
52958 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52959 PyObject *resultobj = 0;
52960 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52961 wxWindow *arg2 = (wxWindow *) 0 ;
52962 int *arg3 = (int *) 0 ;
52963 bool result;
52964 void *argp1 = 0 ;
52965 int res1 = 0 ;
52966 void *argp2 = 0 ;
52967 int res2 = 0 ;
52968 int temp3 ;
52969 int res3 = SWIG_TMPOBJ ;
52970 PyObject * obj0 = 0 ;
52971 PyObject * obj1 = 0 ;
52972 char * kwnames[] = {
52973 (char *) "self",(char *) "win", NULL
52974 };
52975
52976 arg3 = &temp3;
52977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52979 if (!SWIG_IsOK(res1)) {
52980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52981 }
52982 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52984 if (!SWIG_IsOK(res2)) {
52985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52986 }
52987 arg2 = reinterpret_cast< wxWindow * >(argp2);
52988 {
52989 PyThreadState* __tstate = wxPyBeginAllowThreads();
52990 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52991 wxPyEndAllowThreads(__tstate);
52992 if (PyErr_Occurred()) SWIG_fail;
52993 }
52994 {
52995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52996 }
52997 if (SWIG_IsTmpObj(res3)) {
52998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52999 } else {
53000 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53002 }
53003 return resultobj;
53004 fail:
53005 return NULL;
53006 }
53007
53008
53009 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53010 PyObject *resultobj = 0;
53011 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53012 bool result;
53013 void *argp1 = 0 ;
53014 int res1 = 0 ;
53015 PyObject *swig_obj[1] ;
53016
53017 if (!args) SWIG_fail;
53018 swig_obj[0] = args;
53019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53020 if (!SWIG_IsOK(res1)) {
53021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53022 }
53023 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53024 {
53025 PyThreadState* __tstate = wxPyBeginAllowThreads();
53026 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53027 wxPyEndAllowThreads(__tstate);
53028 if (PyErr_Occurred()) SWIG_fail;
53029 }
53030 {
53031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53032 }
53033 return resultobj;
53034 fail:
53035 return NULL;
53036 }
53037
53038
53039 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53040 PyObject *obj;
53041 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53042 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53043 return SWIG_Py_Void();
53044 }
53045
53046 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53047 return SWIG_Python_InitShadowInstance(args);
53048 }
53049
53050 static PyMethodDef SwigMethods[] = {
53051 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53052 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53053 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53054 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53055 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53056 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53057 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53058 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53059 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53061 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53072 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53073 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53074 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53076 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53077 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53078 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53079 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53080 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53081 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53082 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53084 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53090 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53091 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53092 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53093 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53094 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53095 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53096 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53098 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53106 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53107 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53113 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53114 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53116 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53118 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53120 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53122 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53124 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53126 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53127 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53129 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53131 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53132 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53133 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53134 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53154 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53155 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53156 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53157 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53158 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53159 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53160 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53161 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53163 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53164 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53165 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53170 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53171 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53172 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53173 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53180 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53187 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53188 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53189 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53190 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53192 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53193 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53194 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53196 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53197 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53198 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53199 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53204 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53205 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53206 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53207 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53208 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53209 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53212 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53213 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53214 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53216 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53217 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53219 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53220 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53221 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53222 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53223 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53224 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53225 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53226 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53227 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53228 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53229 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53234 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53240 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53241 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53242 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53243 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53245 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53248 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53250 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53253 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53254 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53255 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53258 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53259 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53260 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53264 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53265 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53266 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53270 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53275 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53276 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53277 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53278 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53279 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53280 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53281 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53288 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53289 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53291 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53292 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53293 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53299 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53300 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53302 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53303 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53304 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53305 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53306 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53307 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53308 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53309 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53311 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53312 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53313 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53314 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53315 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53316 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53317 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53318 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53320 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53329 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53341 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53342 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53357 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53358 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53359 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53360 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53363 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53365 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53367 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53369 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53371 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53374 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53375 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53376 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53377 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53379 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53396 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53397 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53403 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53404 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53406 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53407 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53408 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53409 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53410 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53411 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53412 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53413 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53414 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53415 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53416 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53417 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53418 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53419 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53420 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53421 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53422 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53423 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53424 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53425 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53426 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53427 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53428 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53430 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53431 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53432 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53433 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53434 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53435 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53436 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53437 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53438 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53440 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53441 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53442 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53443 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53446 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53450 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53454 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53455 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53456 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53457 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53459 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53460 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53462 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53464 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53466 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53468 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53469 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53470 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53472 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53473 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53475 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53476 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53477 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53479 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53480 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53481 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53483 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53485 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53486 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53487 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53489 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53491 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53492 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53494 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53495 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53496 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53498 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53499 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53500 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53501 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53502 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53504 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53505 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53508 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53509 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53511 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53512 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53515 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53516 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53518 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53524 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53525 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53526 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53527 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53528 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53529 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53530 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53531 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53532 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53533 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53534 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53535 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53536 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53537 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53538 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53539 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53540 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53541 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53542 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53543 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53544 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53545 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53546 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53547 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53549 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53550 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53551 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53552 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53553 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53554 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53555 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53556 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53557 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53558 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53559 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53560 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53561 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53562 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53563 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53564 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53565 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53566 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53567 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53568 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53569 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53570 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53571 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53572 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53573 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53574 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53575 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53576 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53577 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53578 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53579 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53580 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53582 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53583 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53585 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53586 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53587 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53588 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53590 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53591 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53592 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53593 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53594 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53595 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53596 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53597 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53598 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53600 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53601 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53602 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53603 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53604 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53605 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53606 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53607 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53608 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53609 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53610 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53611 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53612 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53613 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53614 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53615 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53616 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53617 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53618 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53619 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53620 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53621 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53622 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53623 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53624 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53625 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53626 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53627 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53629 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53630 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53633 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53634 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53635 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53636 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53637 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53638 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53640 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53641 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53644 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53645 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53647 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53648 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53650 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53651 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53653 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53654 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53655 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53657 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53659 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53660 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53662 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53663 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53664 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53666 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53667 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53668 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53670 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53671 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53673 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53674 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53675 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53676 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53677 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53680 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53682 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53684 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53685 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53686 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53689 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53690 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53691 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53693 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53694 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53695 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53697 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53698 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53699 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53700 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53701 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53702 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53704 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53705 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53706 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53707 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53708 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53709 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53710 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53711 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53717 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53719 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53721 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53722 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53723 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53724 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53725 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53726 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53728 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53729 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53730 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53732 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53733 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53734 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53735 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53736 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53739 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53740 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53741 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53744 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53745 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53746 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53747 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53748 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53750 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53752 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53755 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53757 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53758 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53760 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53761 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53762 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53764 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53765 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53766 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53768 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53770 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53771 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53772 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53774 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53776 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53778 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53779 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53781 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53782 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53784 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53786 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53787 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53788 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53790 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53792 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53793 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53794 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53796 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53798 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53799 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53800 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53801 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53803 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53805 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53807 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53809 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53810 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53812 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53813 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53814 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53815 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53816 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53817 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53818 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53819 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53821 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53823 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53825 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53827 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53829 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53831 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53832 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53833 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53834 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53835 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53836 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53842 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53843 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53844 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53845 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53846 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53847 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53848 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53849 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53851 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53853 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53854 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53856 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53857 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53858 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53859 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53861 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53862 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53863 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53864 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53866 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53867 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53869 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53870 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53871 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53873 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53875 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53876 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53877 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53878 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53879 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53881 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53882 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53883 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53884 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53886 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53887 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53888 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53889 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53890 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53891 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53892 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53893 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53894 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53895 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53897 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53900 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53901 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53902 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53904 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53906 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53908 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53910 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53911 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53921 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53922 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53926 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53927 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53928 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53929 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53930 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53931 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53932 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53933 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53934 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53935 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53936 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53937 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53938 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53939 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53940 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53942 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53943 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53946 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53947 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53952 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53953 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53956 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53957 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53958 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53959 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53962 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53963 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53964 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53966 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53968 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53969 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53970 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53972 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53974 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53976 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53979 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53980 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53981 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53982 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53983 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53984 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53988 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53989 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53990 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53991 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53998 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54004 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54005 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54006 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54007 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54008 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54010 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54020 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54021 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54022 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54023 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54026 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54027 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54028 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54029 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54031 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54032 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54036 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54042 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54043 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54044 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54045 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54047 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54048 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54050 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54053 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54055 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54056 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54057 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54066 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54070 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54071 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54073 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54083 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54084 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54085 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54086 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54090 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54093 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54095 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54098 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54100 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54101 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54104 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54106 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54107 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54108 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54109 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54111 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54112 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54117 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54118 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54119 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54121 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54122 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54123 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54125 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54127 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54128 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54129 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54131 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54132 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54135 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54143 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54150 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54158 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54161 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54162 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54175 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54177 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54179 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54180 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54182 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54184 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54185 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54187 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54188 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54189 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54193 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54212 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54213 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54215 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54216 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54218 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54219 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54220 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54222 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54223 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54226 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54227 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54229 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54230 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54232 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54235 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54236 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54238 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54240 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54242 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54243 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54245 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54246 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54249 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54251 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54253 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54255 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54258 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54260 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54261 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54262 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54264 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54265 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54266 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54268 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54270 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54271 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54273 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54275 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54276 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54280 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54284 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54285 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54287 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54291 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54292 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54293 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54295 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54296 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54297 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54298 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54302 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54303 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54304 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54305 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54307 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54308 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54313 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54314 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54315 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54316 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54317 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54319 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54321 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54323 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54324 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54326 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54328 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54331 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54332 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54333 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54335 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54336 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54337 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54351 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54352 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54353 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54354 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54355 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54356 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54362 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54363 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54367 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54368 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54369 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54370 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54371 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54373 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54375 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54376 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54378 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54379 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54380 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54386 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54387 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54388 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54389 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54390 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54391 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54398 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54400 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54401 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54402 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54403 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54404 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54405 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54407 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54411 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54412 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54413 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54414 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54415 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54416 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54417 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54419 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54420 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54421 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54427 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54428 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54429 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54431 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54432 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54433 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54439 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54440 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54441 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54442 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54443 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54447 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54448 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54453 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54454 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54456 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54457 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54462 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54464 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54465 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54466 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54467 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54468 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54473 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54474 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54483 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54484 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54485 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54486 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54489 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54491 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54492 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54493 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54494 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54496 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54501 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54502 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54503 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54504 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54505 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54506 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54507 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54508 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54509 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54510 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54511 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54513 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54514 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54515 { NULL, NULL, 0, NULL }
54516 };
54517
54518
54519 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54520
54521 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54522 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54523 }
54524 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54525 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54526 }
54527 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54528 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54529 }
54530 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54531 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54532 }
54533 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54534 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54535 }
54536 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54537 return (void *)((wxSizer *) ((wxGridSizer *) x));
54538 }
54539 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54540 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54541 }
54542 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54543 return (void *)((wxSizer *) ((wxPySizer *) x));
54544 }
54545 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54546 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54547 }
54548 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54549 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54550 }
54551 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54552 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54553 }
54554 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54555 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54556 }
54557 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54558 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54559 }
54560 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54561 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54562 }
54563 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54564 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54565 }
54566 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54567 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54568 }
54569 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54570 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54571 }
54572 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54573 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54574 }
54575 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54576 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54577 }
54578 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54579 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54580 }
54581 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54582 return (void *)((wxEvent *) ((wxPyEvent *) x));
54583 }
54584 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54585 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54586 }
54587 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54588 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54589 }
54590 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54591 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54592 }
54593 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54594 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54595 }
54596 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54597 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54598 }
54599 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54600 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54601 }
54602 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54603 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54604 }
54605 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54606 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54607 }
54608 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54609 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54610 }
54611 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54612 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54613 }
54614 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54615 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54616 }
54617 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54618 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54619 }
54620 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54621 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54622 }
54623 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54624 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54625 }
54626 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54627 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54628 }
54629 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54630 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54631 }
54632 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54633 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54634 }
54635 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54636 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54637 }
54638 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54639 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54640 }
54641 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54642 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54643 }
54644 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54645 return (void *)((wxEvent *) ((wxShowEvent *) x));
54646 }
54647 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54648 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54649 }
54650 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54651 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54652 }
54653 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54654 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54655 }
54656 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54657 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54658 }
54659 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54660 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54661 }
54662 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54663 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54664 }
54665 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54666 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54667 }
54668 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54669 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54670 }
54671 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54672 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54673 }
54674 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54675 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54676 }
54677 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54678 return (void *)((wxControl *) ((wxControlWithItems *) x));
54679 }
54680 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54681 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54682 }
54683 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54684 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54685 }
54686 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54687 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54688 }
54689 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54690 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54691 }
54692 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54693 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54694 }
54695 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54696 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54697 }
54698 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54699 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54700 }
54701 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54702 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54703 }
54704 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54705 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54706 }
54707 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54708 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54709 }
54710 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54711 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54712 }
54713 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54714 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54715 }
54716 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54717 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54718 }
54719 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54720 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54721 }
54722 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54723 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54724 }
54725 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54726 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54727 }
54728 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54729 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54730 }
54731 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54732 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54733 }
54734 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54735 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54736 }
54737 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54738 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54739 }
54740 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54741 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54742 }
54743 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54744 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54745 }
54746 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54747 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54748 }
54749 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54750 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54751 }
54752 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54753 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54754 }
54755 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54756 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54757 }
54758 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54759 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54760 }
54761 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54762 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54763 }
54764 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54765 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54766 }
54767 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54768 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54769 }
54770 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54771 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54772 }
54773 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54774 return (void *)((wxObject *) ((wxSizerItem *) x));
54775 }
54776 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54777 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54778 }
54779 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54780 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54781 }
54782 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54783 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54784 }
54785 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54786 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54787 }
54788 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54789 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54790 }
54791 static void *_p_wxSizerTo_p_wxObject(void *x) {
54792 return (void *)((wxObject *) ((wxSizer *) x));
54793 }
54794 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54795 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54796 }
54797 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54798 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54799 }
54800 static void *_p_wxEventTo_p_wxObject(void *x) {
54801 return (void *)((wxObject *) ((wxEvent *) x));
54802 }
54803 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54804 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54805 }
54806 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54807 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54808 }
54809 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54810 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54811 }
54812 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54813 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54814 }
54815 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54816 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54817 }
54818 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54819 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54820 }
54821 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54822 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54823 }
54824 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54825 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54826 }
54827 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54828 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54829 }
54830 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54831 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54832 }
54833 static void *_p_wxControlTo_p_wxObject(void *x) {
54834 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54835 }
54836 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54837 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54838 }
54839 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54840 return (void *)((wxObject *) ((wxFSFile *) x));
54841 }
54842 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54843 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54844 }
54845 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54846 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54847 }
54848 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54849 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54850 }
54851 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54852 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54853 }
54854 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54855 return (void *)((wxObject *) ((wxMenuItem *) x));
54856 }
54857 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54858 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54859 }
54860 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54861 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54862 }
54863 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54864 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54865 }
54866 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54867 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54868 }
54869 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54870 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54871 }
54872 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54873 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54874 }
54875 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54876 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54877 }
54878 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54879 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54880 }
54881 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54882 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54883 }
54884 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54885 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54886 }
54887 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54888 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54889 }
54890 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54891 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54892 }
54893 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54894 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54895 }
54896 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54897 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54898 }
54899 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54900 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54901 }
54902 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54903 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54904 }
54905 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54906 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54907 }
54908 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54909 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54910 }
54911 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54912 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54913 }
54914 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54915 return (void *)((wxObject *) ((wxImageHandler *) x));
54916 }
54917 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54918 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54919 }
54920 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54921 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54922 }
54923 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54924 return (void *)((wxObject *) ((wxEvtHandler *) x));
54925 }
54926 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54927 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54928 }
54929 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54930 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54931 }
54932 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54933 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54934 }
54935 static void *_p_wxImageTo_p_wxObject(void *x) {
54936 return (void *)((wxObject *) ((wxImage *) x));
54937 }
54938 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54939 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54940 }
54941 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54942 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54943 }
54944 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54945 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54946 }
54947 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54948 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54949 }
54950 static void *_p_wxWindowTo_p_wxObject(void *x) {
54951 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54952 }
54953 static void *_p_wxMenuTo_p_wxObject(void *x) {
54954 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54955 }
54956 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54957 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54958 }
54959 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54960 return (void *)((wxObject *) ((wxFileSystem *) x));
54961 }
54962 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54963 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54964 }
54965 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54966 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54967 }
54968 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54969 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54970 }
54971 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54972 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54973 }
54974 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54975 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54976 }
54977 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54978 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54979 }
54980 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54981 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54982 }
54983 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54984 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54985 }
54986 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54987 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54988 }
54989 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54990 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54991 }
54992 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54993 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54994 }
54995 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54996 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54997 }
54998 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54999 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55000 }
55001 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55002 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55003 }
55004 static void *_p_wxControlTo_p_wxWindow(void *x) {
55005 return (void *)((wxWindow *) ((wxControl *) x));
55006 }
55007 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55008 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55009 }
55010 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55011 return (void *)((wxWindow *) ((wxMenuBar *) x));
55012 }
55013 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55014 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55015 }
55016 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55017 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55018 }
55019 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55020 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55021 }
55022 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55023 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55024 }
55025 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55026 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55027 }
55028 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55029 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55030 }
55031 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55032 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55033 }
55034 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55035 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55036 }
55037 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55038 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55039 }
55040 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55041 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55042 }
55043 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55044 return (void *)((wxValidator *) ((wxPyValidator *) x));
55045 }
55046 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55047 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55048 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};
55049 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55050 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55051 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55052 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55053 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55054 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55055 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55056 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55057 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55058 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55059 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55060 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55061 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55062 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55063 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55064 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55065 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55066 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55067 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55068 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55069 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55070 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55071 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55072 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55074 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55075 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55168 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55169 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55170 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55171 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55172 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55173 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55174 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55175 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55176 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55177 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55178
55179 static swig_type_info *swig_type_initial[] = {
55180 &_swigt__p_buffer,
55181 &_swigt__p_char,
55182 &_swigt__p_form_ops_t,
55183 &_swigt__p_int,
55184 &_swigt__p_long,
55185 &_swigt__p_unsigned_char,
55186 &_swigt__p_unsigned_int,
55187 &_swigt__p_unsigned_long,
55188 &_swigt__p_wxANIHandler,
55189 &_swigt__p_wxAcceleratorEntry,
55190 &_swigt__p_wxAcceleratorTable,
55191 &_swigt__p_wxActivateEvent,
55192 &_swigt__p_wxAppTraits,
55193 &_swigt__p_wxArrayString,
55194 &_swigt__p_wxBMPHandler,
55195 &_swigt__p_wxBitmap,
55196 &_swigt__p_wxBoxSizer,
55197 &_swigt__p_wxButton,
55198 &_swigt__p_wxCURHandler,
55199 &_swigt__p_wxCaret,
55200 &_swigt__p_wxChildFocusEvent,
55201 &_swigt__p_wxClipboardTextEvent,
55202 &_swigt__p_wxCloseEvent,
55203 &_swigt__p_wxColour,
55204 &_swigt__p_wxCommandEvent,
55205 &_swigt__p_wxContextMenuEvent,
55206 &_swigt__p_wxControl,
55207 &_swigt__p_wxControlWithItems,
55208 &_swigt__p_wxCursor,
55209 &_swigt__p_wxDC,
55210 &_swigt__p_wxDateEvent,
55211 &_swigt__p_wxDateTime,
55212 &_swigt__p_wxDisplayChangedEvent,
55213 &_swigt__p_wxDropFilesEvent,
55214 &_swigt__p_wxDuplexMode,
55215 &_swigt__p_wxEraseEvent,
55216 &_swigt__p_wxEvent,
55217 &_swigt__p_wxEventLoop,
55218 &_swigt__p_wxEventLoopActivator,
55219 &_swigt__p_wxEvtHandler,
55220 &_swigt__p_wxFSFile,
55221 &_swigt__p_wxFileSystem,
55222 &_swigt__p_wxFileSystemHandler,
55223 &_swigt__p_wxFlexGridSizer,
55224 &_swigt__p_wxFocusEvent,
55225 &_swigt__p_wxFont,
55226 &_swigt__p_wxFrame,
55227 &_swigt__p_wxGBPosition,
55228 &_swigt__p_wxGBSizerItem,
55229 &_swigt__p_wxGBSpan,
55230 &_swigt__p_wxGIFHandler,
55231 &_swigt__p_wxGridBagSizer,
55232 &_swigt__p_wxGridSizer,
55233 &_swigt__p_wxHelpEvent__Origin,
55234 &_swigt__p_wxICOHandler,
55235 &_swigt__p_wxIconizeEvent,
55236 &_swigt__p_wxIdleEvent,
55237 &_swigt__p_wxImage,
55238 &_swigt__p_wxImageHandler,
55239 &_swigt__p_wxImageHistogram,
55240 &_swigt__p_wxImage_HSVValue,
55241 &_swigt__p_wxImage_RGBValue,
55242 &_swigt__p_wxIndividualLayoutConstraint,
55243 &_swigt__p_wxInitDialogEvent,
55244 &_swigt__p_wxInputStream,
55245 &_swigt__p_wxInternetFSHandler,
55246 &_swigt__p_wxItemContainer,
55247 &_swigt__p_wxJPEGHandler,
55248 &_swigt__p_wxKeyEvent,
55249 &_swigt__p_wxLayoutConstraints,
55250 &_swigt__p_wxMaximizeEvent,
55251 &_swigt__p_wxMemoryFSHandler,
55252 &_swigt__p_wxMenu,
55253 &_swigt__p_wxMenuBar,
55254 &_swigt__p_wxMenuBarBase,
55255 &_swigt__p_wxMenuEvent,
55256 &_swigt__p_wxMenuItem,
55257 &_swigt__p_wxMouseCaptureChangedEvent,
55258 &_swigt__p_wxMouseCaptureLostEvent,
55259 &_swigt__p_wxMouseEvent,
55260 &_swigt__p_wxMoveEvent,
55261 &_swigt__p_wxNavigationKeyEvent,
55262 &_swigt__p_wxNcPaintEvent,
55263 &_swigt__p_wxNotifyEvent,
55264 &_swigt__p_wxObject,
55265 &_swigt__p_wxOutputStream,
55266 &_swigt__p_wxPCXHandler,
55267 &_swigt__p_wxPNGHandler,
55268 &_swigt__p_wxPNMHandler,
55269 &_swigt__p_wxPaintEvent,
55270 &_swigt__p_wxPaletteChangedEvent,
55271 &_swigt__p_wxPaperSize,
55272 &_swigt__p_wxPoint,
55273 &_swigt__p_wxPoint2D,
55274 &_swigt__p_wxPropagateOnce,
55275 &_swigt__p_wxPropagationDisabler,
55276 &_swigt__p_wxPyApp,
55277 &_swigt__p_wxPyCommandEvent,
55278 &_swigt__p_wxPyDropTarget,
55279 &_swigt__p_wxPyEvent,
55280 &_swigt__p_wxPyFileSystemHandler,
55281 &_swigt__p_wxPyImageHandler,
55282 &_swigt__p_wxPyInputStream,
55283 &_swigt__p_wxPySizer,
55284 &_swigt__p_wxPyValidator,
55285 &_swigt__p_wxQuantize,
55286 &_swigt__p_wxQueryNewPaletteEvent,
55287 &_swigt__p_wxRealPoint,
55288 &_swigt__p_wxRect,
55289 &_swigt__p_wxRegion,
55290 &_swigt__p_wxScrollEvent,
55291 &_swigt__p_wxScrollWinEvent,
55292 &_swigt__p_wxSetCursorEvent,
55293 &_swigt__p_wxShowEvent,
55294 &_swigt__p_wxSize,
55295 &_swigt__p_wxSizeEvent,
55296 &_swigt__p_wxSizer,
55297 &_swigt__p_wxSizerItem,
55298 &_swigt__p_wxStaticBox,
55299 &_swigt__p_wxStaticBoxSizer,
55300 &_swigt__p_wxStdDialogButtonSizer,
55301 &_swigt__p_wxSysColourChangedEvent,
55302 &_swigt__p_wxTIFFHandler,
55303 &_swigt__p_wxToolTip,
55304 &_swigt__p_wxUpdateUIEvent,
55305 &_swigt__p_wxValidator,
55306 &_swigt__p_wxVisualAttributes,
55307 &_swigt__p_wxWindow,
55308 &_swigt__p_wxWindowCreateEvent,
55309 &_swigt__p_wxWindowDestroyEvent,
55310 &_swigt__p_wxXPMHandler,
55311 &_swigt__p_wxZipFSHandler,
55312 };
55313
55314 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55315 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55316 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55317 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55318 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55319 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55320 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55321 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55322 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55323 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55324 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55325 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55326 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55327 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55328 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}};
55329 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55330 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}};
55331 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55332 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}};
55333 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55334 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55335 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55336 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55337 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55338 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}};
55339 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55340 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}};
55341 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55342 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55343 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55344 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55345 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55346 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55347 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55348 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55349 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55350 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}};
55351 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55353 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}};
55354 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55355 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55356 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}};
55357 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}};
55358 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55359 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55361 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55362 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55363 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55364 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55365 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55366 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}};
55367 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55368 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}};
55369 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55370 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55371 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55372 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
55373 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55374 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55375 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55376 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55377 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55379 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55380 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}};
55381 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55382 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55383 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55384 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55385 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55387 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55388 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55389 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55392 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55406 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55407 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55420 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55421 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55429 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55430 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}};
55431 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}};
55432 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55436 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55437 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55438 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55439 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}};
55440 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55441 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}};
55442 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55443 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55444 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55445 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55446
55447 static swig_cast_info *swig_cast_initial[] = {
55448 _swigc__p_buffer,
55449 _swigc__p_char,
55450 _swigc__p_form_ops_t,
55451 _swigc__p_int,
55452 _swigc__p_long,
55453 _swigc__p_unsigned_char,
55454 _swigc__p_unsigned_int,
55455 _swigc__p_unsigned_long,
55456 _swigc__p_wxANIHandler,
55457 _swigc__p_wxAcceleratorEntry,
55458 _swigc__p_wxAcceleratorTable,
55459 _swigc__p_wxActivateEvent,
55460 _swigc__p_wxAppTraits,
55461 _swigc__p_wxArrayString,
55462 _swigc__p_wxBMPHandler,
55463 _swigc__p_wxBitmap,
55464 _swigc__p_wxBoxSizer,
55465 _swigc__p_wxButton,
55466 _swigc__p_wxCURHandler,
55467 _swigc__p_wxCaret,
55468 _swigc__p_wxChildFocusEvent,
55469 _swigc__p_wxClipboardTextEvent,
55470 _swigc__p_wxCloseEvent,
55471 _swigc__p_wxColour,
55472 _swigc__p_wxCommandEvent,
55473 _swigc__p_wxContextMenuEvent,
55474 _swigc__p_wxControl,
55475 _swigc__p_wxControlWithItems,
55476 _swigc__p_wxCursor,
55477 _swigc__p_wxDC,
55478 _swigc__p_wxDateEvent,
55479 _swigc__p_wxDateTime,
55480 _swigc__p_wxDisplayChangedEvent,
55481 _swigc__p_wxDropFilesEvent,
55482 _swigc__p_wxDuplexMode,
55483 _swigc__p_wxEraseEvent,
55484 _swigc__p_wxEvent,
55485 _swigc__p_wxEventLoop,
55486 _swigc__p_wxEventLoopActivator,
55487 _swigc__p_wxEvtHandler,
55488 _swigc__p_wxFSFile,
55489 _swigc__p_wxFileSystem,
55490 _swigc__p_wxFileSystemHandler,
55491 _swigc__p_wxFlexGridSizer,
55492 _swigc__p_wxFocusEvent,
55493 _swigc__p_wxFont,
55494 _swigc__p_wxFrame,
55495 _swigc__p_wxGBPosition,
55496 _swigc__p_wxGBSizerItem,
55497 _swigc__p_wxGBSpan,
55498 _swigc__p_wxGIFHandler,
55499 _swigc__p_wxGridBagSizer,
55500 _swigc__p_wxGridSizer,
55501 _swigc__p_wxHelpEvent__Origin,
55502 _swigc__p_wxICOHandler,
55503 _swigc__p_wxIconizeEvent,
55504 _swigc__p_wxIdleEvent,
55505 _swigc__p_wxImage,
55506 _swigc__p_wxImageHandler,
55507 _swigc__p_wxImageHistogram,
55508 _swigc__p_wxImage_HSVValue,
55509 _swigc__p_wxImage_RGBValue,
55510 _swigc__p_wxIndividualLayoutConstraint,
55511 _swigc__p_wxInitDialogEvent,
55512 _swigc__p_wxInputStream,
55513 _swigc__p_wxInternetFSHandler,
55514 _swigc__p_wxItemContainer,
55515 _swigc__p_wxJPEGHandler,
55516 _swigc__p_wxKeyEvent,
55517 _swigc__p_wxLayoutConstraints,
55518 _swigc__p_wxMaximizeEvent,
55519 _swigc__p_wxMemoryFSHandler,
55520 _swigc__p_wxMenu,
55521 _swigc__p_wxMenuBar,
55522 _swigc__p_wxMenuBarBase,
55523 _swigc__p_wxMenuEvent,
55524 _swigc__p_wxMenuItem,
55525 _swigc__p_wxMouseCaptureChangedEvent,
55526 _swigc__p_wxMouseCaptureLostEvent,
55527 _swigc__p_wxMouseEvent,
55528 _swigc__p_wxMoveEvent,
55529 _swigc__p_wxNavigationKeyEvent,
55530 _swigc__p_wxNcPaintEvent,
55531 _swigc__p_wxNotifyEvent,
55532 _swigc__p_wxObject,
55533 _swigc__p_wxOutputStream,
55534 _swigc__p_wxPCXHandler,
55535 _swigc__p_wxPNGHandler,
55536 _swigc__p_wxPNMHandler,
55537 _swigc__p_wxPaintEvent,
55538 _swigc__p_wxPaletteChangedEvent,
55539 _swigc__p_wxPaperSize,
55540 _swigc__p_wxPoint,
55541 _swigc__p_wxPoint2D,
55542 _swigc__p_wxPropagateOnce,
55543 _swigc__p_wxPropagationDisabler,
55544 _swigc__p_wxPyApp,
55545 _swigc__p_wxPyCommandEvent,
55546 _swigc__p_wxPyDropTarget,
55547 _swigc__p_wxPyEvent,
55548 _swigc__p_wxPyFileSystemHandler,
55549 _swigc__p_wxPyImageHandler,
55550 _swigc__p_wxPyInputStream,
55551 _swigc__p_wxPySizer,
55552 _swigc__p_wxPyValidator,
55553 _swigc__p_wxQuantize,
55554 _swigc__p_wxQueryNewPaletteEvent,
55555 _swigc__p_wxRealPoint,
55556 _swigc__p_wxRect,
55557 _swigc__p_wxRegion,
55558 _swigc__p_wxScrollEvent,
55559 _swigc__p_wxScrollWinEvent,
55560 _swigc__p_wxSetCursorEvent,
55561 _swigc__p_wxShowEvent,
55562 _swigc__p_wxSize,
55563 _swigc__p_wxSizeEvent,
55564 _swigc__p_wxSizer,
55565 _swigc__p_wxSizerItem,
55566 _swigc__p_wxStaticBox,
55567 _swigc__p_wxStaticBoxSizer,
55568 _swigc__p_wxStdDialogButtonSizer,
55569 _swigc__p_wxSysColourChangedEvent,
55570 _swigc__p_wxTIFFHandler,
55571 _swigc__p_wxToolTip,
55572 _swigc__p_wxUpdateUIEvent,
55573 _swigc__p_wxValidator,
55574 _swigc__p_wxVisualAttributes,
55575 _swigc__p_wxWindow,
55576 _swigc__p_wxWindowCreateEvent,
55577 _swigc__p_wxWindowDestroyEvent,
55578 _swigc__p_wxXPMHandler,
55579 _swigc__p_wxZipFSHandler,
55580 };
55581
55582
55583 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55584
55585 static swig_const_info swig_const_table[] = {
55586 {0, 0, 0, 0.0, 0, 0}};
55587
55588 #ifdef __cplusplus
55589 }
55590 #endif
55591 /* -----------------------------------------------------------------------------
55592 * Type initialization:
55593 * This problem is tough by the requirement that no dynamic
55594 * memory is used. Also, since swig_type_info structures store pointers to
55595 * swig_cast_info structures and swig_cast_info structures store pointers back
55596 * to swig_type_info structures, we need some lookup code at initialization.
55597 * The idea is that swig generates all the structures that are needed.
55598 * The runtime then collects these partially filled structures.
55599 * The SWIG_InitializeModule function takes these initial arrays out of
55600 * swig_module, and does all the lookup, filling in the swig_module.types
55601 * array with the correct data and linking the correct swig_cast_info
55602 * structures together.
55603 *
55604 * The generated swig_type_info structures are assigned staticly to an initial
55605 * array. We just loop though that array, and handle each type individually.
55606 * First we lookup if this type has been already loaded, and if so, use the
55607 * loaded structure instead of the generated one. Then we have to fill in the
55608 * cast linked list. The cast data is initially stored in something like a
55609 * two-dimensional array. Each row corresponds to a type (there are the same
55610 * number of rows as there are in the swig_type_initial array). Each entry in
55611 * a column is one of the swig_cast_info structures for that type.
55612 * The cast_initial array is actually an array of arrays, because each row has
55613 * a variable number of columns. So to actually build the cast linked list,
55614 * we find the array of casts associated with the type, and loop through it
55615 * adding the casts to the list. The one last trick we need to do is making
55616 * sure the type pointer in the swig_cast_info struct is correct.
55617 *
55618 * First off, we lookup the cast->type name to see if it is already loaded.
55619 * There are three cases to handle:
55620 * 1) If the cast->type has already been loaded AND the type we are adding
55621 * casting info to has not been loaded (it is in this module), THEN we
55622 * replace the cast->type pointer with the type pointer that has already
55623 * been loaded.
55624 * 2) If BOTH types (the one we are adding casting info to, and the
55625 * cast->type) are loaded, THEN the cast info has already been loaded by
55626 * the previous module so we just ignore it.
55627 * 3) Finally, if cast->type has not already been loaded, then we add that
55628 * swig_cast_info to the linked list (because the cast->type) pointer will
55629 * be correct.
55630 * ----------------------------------------------------------------------------- */
55631
55632 #ifdef __cplusplus
55633 extern "C" {
55634 #if 0
55635 } /* c-mode */
55636 #endif
55637 #endif
55638
55639 #if 0
55640 #define SWIGRUNTIME_DEBUG
55641 #endif
55642
55643 SWIGRUNTIME void
55644 SWIG_InitializeModule(void *clientdata) {
55645 size_t i;
55646 swig_module_info *module_head;
55647 static int init_run = 0;
55648
55649 clientdata = clientdata;
55650
55651 if (init_run) return;
55652 init_run = 1;
55653
55654 /* Initialize the swig_module */
55655 swig_module.type_initial = swig_type_initial;
55656 swig_module.cast_initial = swig_cast_initial;
55657
55658 /* Try and load any already created modules */
55659 module_head = SWIG_GetModule(clientdata);
55660 if (module_head) {
55661 swig_module.next = module_head->next;
55662 module_head->next = &swig_module;
55663 } else {
55664 /* This is the first module loaded */
55665 swig_module.next = &swig_module;
55666 SWIG_SetModule(clientdata, &swig_module);
55667 }
55668
55669 /* Now work on filling in swig_module.types */
55670 #ifdef SWIGRUNTIME_DEBUG
55671 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55672 #endif
55673 for (i = 0; i < swig_module.size; ++i) {
55674 swig_type_info *type = 0;
55675 swig_type_info *ret;
55676 swig_cast_info *cast;
55677
55678 #ifdef SWIGRUNTIME_DEBUG
55679 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55680 #endif
55681
55682 /* if there is another module already loaded */
55683 if (swig_module.next != &swig_module) {
55684 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55685 }
55686 if (type) {
55687 /* Overwrite clientdata field */
55688 #ifdef SWIGRUNTIME_DEBUG
55689 printf("SWIG_InitializeModule: found type %s\n", type->name);
55690 #endif
55691 if (swig_module.type_initial[i]->clientdata) {
55692 type->clientdata = swig_module.type_initial[i]->clientdata;
55693 #ifdef SWIGRUNTIME_DEBUG
55694 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55695 #endif
55696 }
55697 } else {
55698 type = swig_module.type_initial[i];
55699 }
55700
55701 /* Insert casting types */
55702 cast = swig_module.cast_initial[i];
55703 while (cast->type) {
55704 /* Don't need to add information already in the list */
55705 ret = 0;
55706 #ifdef SWIGRUNTIME_DEBUG
55707 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55708 #endif
55709 if (swig_module.next != &swig_module) {
55710 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55711 #ifdef SWIGRUNTIME_DEBUG
55712 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55713 #endif
55714 }
55715 if (ret) {
55716 if (type == swig_module.type_initial[i]) {
55717 #ifdef SWIGRUNTIME_DEBUG
55718 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55719 #endif
55720 cast->type = ret;
55721 ret = 0;
55722 } else {
55723 /* Check for casting already in the list */
55724 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55725 #ifdef SWIGRUNTIME_DEBUG
55726 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55727 #endif
55728 if (!ocast) ret = 0;
55729 }
55730 }
55731
55732 if (!ret) {
55733 #ifdef SWIGRUNTIME_DEBUG
55734 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55735 #endif
55736 if (type->cast) {
55737 type->cast->prev = cast;
55738 cast->next = type->cast;
55739 }
55740 type->cast = cast;
55741 }
55742 cast++;
55743 }
55744 /* Set entry in modules->types array equal to the type */
55745 swig_module.types[i] = type;
55746 }
55747 swig_module.types[i] = 0;
55748
55749 #ifdef SWIGRUNTIME_DEBUG
55750 printf("**** SWIG_InitializeModule: Cast List ******\n");
55751 for (i = 0; i < swig_module.size; ++i) {
55752 int j = 0;
55753 swig_cast_info *cast = swig_module.cast_initial[i];
55754 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55755 while (cast->type) {
55756 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55757 cast++;
55758 ++j;
55759 }
55760 printf("---- Total casts: %d\n",j);
55761 }
55762 printf("**** SWIG_InitializeModule: Cast List ******\n");
55763 #endif
55764 }
55765
55766 /* This function will propagate the clientdata field of type to
55767 * any new swig_type_info structures that have been added into the list
55768 * of equivalent types. It is like calling
55769 * SWIG_TypeClientData(type, clientdata) a second time.
55770 */
55771 SWIGRUNTIME void
55772 SWIG_PropagateClientData(void) {
55773 size_t i;
55774 swig_cast_info *equiv;
55775 static int init_run = 0;
55776
55777 if (init_run) return;
55778 init_run = 1;
55779
55780 for (i = 0; i < swig_module.size; i++) {
55781 if (swig_module.types[i]->clientdata) {
55782 equiv = swig_module.types[i]->cast;
55783 while (equiv) {
55784 if (!equiv->converter) {
55785 if (equiv->type && !equiv->type->clientdata)
55786 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55787 }
55788 equiv = equiv->next;
55789 }
55790 }
55791 }
55792 }
55793
55794 #ifdef __cplusplus
55795 #if 0
55796 {
55797 /* c-mode */
55798 #endif
55799 }
55800 #endif
55801
55802
55803
55804 #ifdef __cplusplus
55805 extern "C" {
55806 #endif
55807
55808 /* Python-specific SWIG API */
55809 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55810 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55811 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55812
55813 /* -----------------------------------------------------------------------------
55814 * global variable support code.
55815 * ----------------------------------------------------------------------------- */
55816
55817 typedef struct swig_globalvar {
55818 char *name; /* Name of global variable */
55819 PyObject *(*get_attr)(void); /* Return the current value */
55820 int (*set_attr)(PyObject *); /* Set the value */
55821 struct swig_globalvar *next;
55822 } swig_globalvar;
55823
55824 typedef struct swig_varlinkobject {
55825 PyObject_HEAD
55826 swig_globalvar *vars;
55827 } swig_varlinkobject;
55828
55829 SWIGINTERN PyObject *
55830 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55831 return PyString_FromString("<Swig global variables>");
55832 }
55833
55834 SWIGINTERN PyObject *
55835 swig_varlink_str(swig_varlinkobject *v) {
55836 PyObject *str = PyString_FromString("(");
55837 swig_globalvar *var;
55838 for (var = v->vars; var; var=var->next) {
55839 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55840 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55841 }
55842 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55843 return str;
55844 }
55845
55846 SWIGINTERN int
55847 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55848 PyObject *str = swig_varlink_str(v);
55849 fprintf(fp,"Swig global variables ");
55850 fprintf(fp,"%s\n", PyString_AsString(str));
55851 Py_DECREF(str);
55852 return 0;
55853 }
55854
55855 SWIGINTERN void
55856 swig_varlink_dealloc(swig_varlinkobject *v) {
55857 swig_globalvar *var = v->vars;
55858 while (var) {
55859 swig_globalvar *n = var->next;
55860 free(var->name);
55861 free(var);
55862 var = n;
55863 }
55864 }
55865
55866 SWIGINTERN PyObject *
55867 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55868 PyObject *res = NULL;
55869 swig_globalvar *var = v->vars;
55870 while (var) {
55871 if (strcmp(var->name,n) == 0) {
55872 res = (*var->get_attr)();
55873 break;
55874 }
55875 var = var->next;
55876 }
55877 if (res == NULL && !PyErr_Occurred()) {
55878 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55879 }
55880 return res;
55881 }
55882
55883 SWIGINTERN int
55884 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55885 int res = 1;
55886 swig_globalvar *var = v->vars;
55887 while (var) {
55888 if (strcmp(var->name,n) == 0) {
55889 res = (*var->set_attr)(p);
55890 break;
55891 }
55892 var = var->next;
55893 }
55894 if (res == 1 && !PyErr_Occurred()) {
55895 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55896 }
55897 return res;
55898 }
55899
55900 SWIGINTERN PyTypeObject*
55901 swig_varlink_type(void) {
55902 static char varlink__doc__[] = "Swig var link object";
55903 static PyTypeObject varlink_type;
55904 static int type_init = 0;
55905 if (!type_init) {
55906 const PyTypeObject tmp
55907 = {
55908 PyObject_HEAD_INIT(NULL)
55909 0, /* Number of items in variable part (ob_size) */
55910 (char *)"swigvarlink", /* Type name (tp_name) */
55911 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55912 0, /* Itemsize (tp_itemsize) */
55913 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55914 (printfunc) swig_varlink_print, /* Print (tp_print) */
55915 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55916 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55917 0, /* tp_compare */
55918 (reprfunc) swig_varlink_repr, /* tp_repr */
55919 0, /* tp_as_number */
55920 0, /* tp_as_sequence */
55921 0, /* tp_as_mapping */
55922 0, /* tp_hash */
55923 0, /* tp_call */
55924 (reprfunc)swig_varlink_str, /* tp_str */
55925 0, /* tp_getattro */
55926 0, /* tp_setattro */
55927 0, /* tp_as_buffer */
55928 0, /* tp_flags */
55929 varlink__doc__, /* tp_doc */
55930 0, /* tp_traverse */
55931 0, /* tp_clear */
55932 0, /* tp_richcompare */
55933 0, /* tp_weaklistoffset */
55934 #if PY_VERSION_HEX >= 0x02020000
55935 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55936 #endif
55937 #if PY_VERSION_HEX >= 0x02030000
55938 0, /* tp_del */
55939 #endif
55940 #ifdef COUNT_ALLOCS
55941 0,0,0,0 /* tp_alloc -> tp_next */
55942 #endif
55943 };
55944 varlink_type = tmp;
55945 varlink_type.ob_type = &PyType_Type;
55946 type_init = 1;
55947 }
55948 return &varlink_type;
55949 }
55950
55951 /* Create a variable linking object for use later */
55952 SWIGINTERN PyObject *
55953 SWIG_Python_newvarlink(void) {
55954 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55955 if (result) {
55956 result->vars = 0;
55957 }
55958 return ((PyObject*) result);
55959 }
55960
55961 SWIGINTERN void
55962 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55963 swig_varlinkobject *v = (swig_varlinkobject *) p;
55964 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55965 if (gv) {
55966 size_t size = strlen(name)+1;
55967 gv->name = (char *)malloc(size);
55968 if (gv->name) {
55969 strncpy(gv->name,name,size);
55970 gv->get_attr = get_attr;
55971 gv->set_attr = set_attr;
55972 gv->next = v->vars;
55973 }
55974 }
55975 v->vars = gv;
55976 }
55977
55978 SWIGINTERN PyObject *
55979 SWIG_globals() {
55980 static PyObject *_SWIG_globals = 0;
55981 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55982 return _SWIG_globals;
55983 }
55984
55985 /* -----------------------------------------------------------------------------
55986 * constants/methods manipulation
55987 * ----------------------------------------------------------------------------- */
55988
55989 /* Install Constants */
55990 SWIGINTERN void
55991 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55992 PyObject *obj = 0;
55993 size_t i;
55994 for (i = 0; constants[i].type; ++i) {
55995 switch(constants[i].type) {
55996 case SWIG_PY_POINTER:
55997 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55998 break;
55999 case SWIG_PY_BINARY:
56000 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56001 break;
56002 default:
56003 obj = 0;
56004 break;
56005 }
56006 if (obj) {
56007 PyDict_SetItemString(d, constants[i].name, obj);
56008 Py_DECREF(obj);
56009 }
56010 }
56011 }
56012
56013 /* -----------------------------------------------------------------------------*/
56014 /* Fix SwigMethods to carry the callback ptrs when needed */
56015 /* -----------------------------------------------------------------------------*/
56016
56017 SWIGINTERN void
56018 SWIG_Python_FixMethods(PyMethodDef *methods,
56019 swig_const_info *const_table,
56020 swig_type_info **types,
56021 swig_type_info **types_initial) {
56022 size_t i;
56023 for (i = 0; methods[i].ml_name; ++i) {
56024 const char *c = methods[i].ml_doc;
56025 if (c && (c = strstr(c, "swig_ptr: "))) {
56026 int j;
56027 swig_const_info *ci = 0;
56028 const char *name = c + 10;
56029 for (j = 0; const_table[j].type; ++j) {
56030 if (strncmp(const_table[j].name, name,
56031 strlen(const_table[j].name)) == 0) {
56032 ci = &(const_table[j]);
56033 break;
56034 }
56035 }
56036 if (ci) {
56037 size_t shift = (ci->ptype) - types;
56038 swig_type_info *ty = types_initial[shift];
56039 size_t ldoc = (c - methods[i].ml_doc);
56040 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56041 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56042 if (ndoc) {
56043 char *buff = ndoc;
56044 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56045 if (ptr) {
56046 strncpy(buff, methods[i].ml_doc, ldoc);
56047 buff += ldoc;
56048 strncpy(buff, "swig_ptr: ", 10);
56049 buff += 10;
56050 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56051 methods[i].ml_doc = ndoc;
56052 }
56053 }
56054 }
56055 }
56056 }
56057 }
56058
56059 #ifdef __cplusplus
56060 }
56061 #endif
56062
56063 /* -----------------------------------------------------------------------------*
56064 * Partial Init method
56065 * -----------------------------------------------------------------------------*/
56066
56067 #ifdef __cplusplus
56068 extern "C"
56069 #endif
56070 SWIGEXPORT void SWIG_init(void) {
56071 PyObject *m, *d;
56072
56073 /* Fix SwigMethods to carry the callback ptrs when needed */
56074 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56075
56076 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56077 d = PyModule_GetDict(m);
56078
56079 SWIG_InitializeModule(0);
56080 SWIG_InstallConstants(d,swig_const_table);
56081
56082
56083
56084 #ifndef wxPyUSE_EXPORT
56085 // Make our API structure a CObject so other modules can import it
56086 // from this module.
56087 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56088 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56089 Py_XDECREF(cobj);
56090 #endif
56091
56092 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56093 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56094 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56095 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56096 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56097 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56098 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56099 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56100 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56101 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56102 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56103 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56104 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56105 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56106 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56107 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56108 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56109 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56110 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56111 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56112 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56113 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56114 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56115 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56116 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56117 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56118 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56119 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56120 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56121 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56122 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56123 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56124 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56125 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56126 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56127 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56128 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56129 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56130 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56131 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56132 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56133 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56134 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56135 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56136 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56137 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56138 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56139 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56140 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56141 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56142 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56143 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56144 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56145 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56146 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56147 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56148 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56149 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56150 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56151 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56152 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56153 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56154 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56155 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56156 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56157 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56158 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56159 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56160 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56161 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56162 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56163 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56164 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56165 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56166 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56167 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56168 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56169 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56170 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56171 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56172 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56173 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56174 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56175 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56176 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56177 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56178 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56179 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56180 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56181 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56182 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56183 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56184 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56185 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56186 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56187 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56188 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56189 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56190 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56191 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56192 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56193 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56194 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56195 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56196 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56197 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56198 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56199 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56200 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56201 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56202 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56203 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56204 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56205 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56206 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56207 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56208 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56209 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56210 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56211 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56212 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56213 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56214 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56215 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56216 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56217 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56218 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56219 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56220 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56221 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56222 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56223 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56224 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56225 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56226 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56227 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56228 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56229 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56230 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56231 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56232 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56233 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56234 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56235 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56236 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56237 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56238 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56239 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56240 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56241 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56242 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56243 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56244 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56245 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56246 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56247 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56248 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56249 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56250 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56251 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56252 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56253 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56254 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56255 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56256 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56257 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56258 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56259 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56260 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56261 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56262 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56263 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56264 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56265 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56266 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56267 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56268 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56269 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56270 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56271 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56272 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56273 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56274 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56275 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56276 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56277 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56278 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56279 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56280 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56281 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56282 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56283 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56284 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56285 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56286 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56287 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56288 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56289 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56290 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56291 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56292 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56293 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56294 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56295 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56296 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56297 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56298 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56299 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56300 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56301 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56302 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56303 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56304 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56305 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56306 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56307 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56308 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56309 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56310 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56311 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56312 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56313 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56314 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56315 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56316 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56317 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56318 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56319 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56320 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56321 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56322 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56323 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56324 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56325 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56326 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56327 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56328 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56329 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56330 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56331 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56332 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56333 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56334 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56335 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56336 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56337 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56338 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56339 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56340 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56341 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56342 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56343 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56344 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56345 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56346 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56347 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56348 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56349 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56350 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56351 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56352 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56353 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56354 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56355 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56356 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56357 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56358 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56359 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56360 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56361 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56362 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56363 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56364 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56365 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56366 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56367 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56368 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56369 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56370 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56371 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56372 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56373 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56374 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56375 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56376 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56377 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56378 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56379 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56380 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56381 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56382 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56383 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56384 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56385 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56386 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56387 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56388 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56389 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56390 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56391 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56392 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56393 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56394 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56395 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56396 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56397 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56398 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56399 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56400 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56401 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56402 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56403 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56404 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56405 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56406 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56407 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56408 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56409 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56410 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56411 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56412 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56413 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56414 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56415 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56416 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56417 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56418 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56419 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56420 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56421 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56422 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56423 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56424 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56425 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56426 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56427 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56428 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56429 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56430 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56431 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56432 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56433 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56434 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56435 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56436 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56437 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56438 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56439 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56440 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56441 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56442 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56443 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56444 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56445 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56446 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56447 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56448 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56449 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56450 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56451 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56452 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56453 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56454 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56455 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56456 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56457 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56458 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56459 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56460 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56461 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56462 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56463 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56464 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56465 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56466 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56467 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56468 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56469 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56470 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56471 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56472 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56473 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56474 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56475 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56476 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56477 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56478 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56479 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56480 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56481 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56482 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56483 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56484 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56485 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56486 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56487 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56488 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56489 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56490 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56491 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56492 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56493 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56494 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56495 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56496 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56497 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56498 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56499 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56500 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56501 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56502 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56503 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56504 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56505 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56506 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56507 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56508 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56509 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56510 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56511 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56512 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56513 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56514 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56515 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56516 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56517 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56518 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56519 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56520 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56521 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56522 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56523 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56524 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56525 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56526 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56527 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56528 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56529 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56530 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56531 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56532 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56533 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56534 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56535 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56536 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56537 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56538 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56539 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56540 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56541 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56542 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56543 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56544 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56545 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56546 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56547 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56548 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56549 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56550 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56551 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56552 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56553 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56554 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56555 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56556 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56557 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56558 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56559 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56560 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56561 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56562 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56563 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56564 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56565 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56566 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56567 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56568 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56569 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56570 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56571 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56572 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56573 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56574 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56575 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56576 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56577 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56578 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56579 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56580 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56581 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56582 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56583 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56584 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56585 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56586 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56587 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56588 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56589 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56590 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56591 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56592 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56593 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56594 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56595 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56596 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56597 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56598 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56599 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56600 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56601 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56602 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56603 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56604 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56605 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56606 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56607 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56608 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56609 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56610 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56611 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56612 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56613 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56614 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56615 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56616 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56617 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56618 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56619 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56620 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56621 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56622 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56623 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56624 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56625 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56626 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56627 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56628 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56629 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56630 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56631 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56632 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56633 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56634 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56635 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56636 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56637 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56638 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56639 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56640 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56641 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56642 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56643 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56644 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56645 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56646 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56647 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56648 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56649 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56650 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56651 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56652 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56653 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56654 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56655 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56656 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56657 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56658 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56659 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56660 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56661 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56662 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56663 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56664 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56665 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56666 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56667 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56668 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56669 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56670 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56671 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56672 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56673 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56674 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56675 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56676 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56677 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56678 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56679 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56680 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56681 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56682 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56683 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56684 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56685 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56686 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56687 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56688 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56689 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56690 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56691 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56692 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56693 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56694 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56695 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56696 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56697 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56698 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56699 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56700 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56701 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56702 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56703 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56704 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56705 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56706 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56707 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56708 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56709 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56710 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56711 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56712 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56713 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56714 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56715 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56716 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56717 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56718 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56719 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56720 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56721 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56722 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56723 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56724 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56725 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56726 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56727 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56728 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56729 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56730 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56731 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56732 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56733 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56734 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56735 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56736 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56737 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56738 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56739 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56740 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56741 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56742 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56743 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56744 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56745 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56746 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56747 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56748 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56749 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56750 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56751 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56752 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56753 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56754 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56755 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56756 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56757 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56758
56759 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56760
56761
56762 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56763
56764 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56765 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56766 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56767 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56768 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56769 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56770 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56771 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56772 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56773 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56774 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56775 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56776 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56777 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56778 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56779 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56780 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56781 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56782 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56783 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56784 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56785 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56786 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56787 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56788 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56789 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56790 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56791 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56792 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56793 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56794 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56795 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56796 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56797 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56798 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56799 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56800 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56801 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56802 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56803 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56804 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56805 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56806 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56807 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56808 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56809 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56810 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56811 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56812 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56813 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56814 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56815 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56816 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56817 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56818 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56819 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56820 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56821 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56822 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56823 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56824 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56825 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56826 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56827 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56828 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56829 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56830 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56831 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56832 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56833 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56834 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56835 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56836 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56837 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56838 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56839 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56840 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56841 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56842 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56843 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56844 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56845 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56846 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56847 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56848 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56849 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56850 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56851 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56852 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56853 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56854 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56855 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56856 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56857 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56858 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56859 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56860 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56861 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56862 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56863 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56864 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56865 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56866 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56867 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56868 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56869 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56870 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56871 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56872 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56873 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56874 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56875 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56876 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56877 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56878 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56879 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56880 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56881 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56882 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56883 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56884 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56885 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56886 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56887 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56888 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56889 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56890 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56891 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56892 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56893 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56894 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56895 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56896 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56897 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56898 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56899 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56900 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56901 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56902 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56903 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56904 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56905 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56906 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56907 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56908 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56909 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56910 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56911 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56912 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56913 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56914 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56915 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56916 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56917 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56918 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56919 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56920 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56921 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56922 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56923 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56924 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56925 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56926 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56927 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56928 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56929 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56930 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56931 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56932 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56933 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56934 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56935 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56936 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56937 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56938 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56939 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56940 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56941 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56942 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56943 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56944 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56945 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56946 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56947 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56948 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56949 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56950 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56951 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56952 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56953 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56954 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56955 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56956 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56957 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56958 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56959 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56960 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56961 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56962 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56963 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56964 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56965 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56966 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56967 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56968 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56969 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56970 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56971
56972 // Initialize threading, some globals and such
56973 __wxPyPreStart(d);
56974
56975
56976 // Although these are defined in __version__ they need to be here too so
56977 // that an assert can be done to ensure that the wxPython and the wxWindows
56978 // versions match.
56979 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56980 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56981 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56982
56983 }
56984
wxWidgets (Impactor)