]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


e08711f9bf717e7d9ccc96710a70cf0bb6c07f8e
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_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 typedef unsigned char* buffer;
3487
3488
3489 // Pull the nested class out to the top level for SWIG's sake
3490 #define wxImage_RGBValue wxImage::RGBValue
3491 #define wxImage_HSVValue wxImage::HSVValue
3492
3493 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3494 if (width > 0 && height > 0)
3495 return new wxImage(width, height, clear);
3496 else
3497 return new wxImage;
3498 }
3499 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3500 return new wxImage(bitmap.ConvertToImage());
3501 }
3502 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3503 if (DATASIZE != width*height*3) {
3504 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3505 return NULL;
3506 }
3507
3508 // Copy the source data so the wxImage can clean it up later
3509 buffer copy = (buffer)malloc(DATASIZE);
3510 if (copy == NULL) {
3511 wxPyBLOCK_THREADS(PyErr_NoMemory());
3512 return NULL;
3513 }
3514 memcpy(copy, data, DATASIZE);
3515 return new wxImage(width, height, copy, false);
3516 }
3517 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3518 if (DATASIZE != width*height*3) {
3519 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3520 return NULL;
3521 }
3522 if (ALPHASIZE != width*height) {
3523 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3524 return NULL;
3525 }
3526
3527 // Copy the source data so the wxImage can clean it up later
3528 buffer dcopy = (buffer)malloc(DATASIZE);
3529 if (dcopy == NULL) {
3530 wxPyBLOCK_THREADS(PyErr_NoMemory());
3531 return NULL;
3532 }
3533 memcpy(dcopy, data, DATASIZE);
3534
3535 buffer acopy = (buffer)malloc(ALPHASIZE);
3536 if (acopy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return NULL;
3539 }
3540 memcpy(acopy, alpha, ALPHASIZE);
3541
3542 return new wxImage(width, height, dcopy, acopy, false);
3543 }
3544 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3545 wxSize size(self->GetWidth(), self->GetHeight());
3546 return size;
3547 }
3548 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3549 buffer data = self->GetData();
3550 int len = self->GetWidth() * self->GetHeight() * 3;
3551 PyObject* rv;
3552 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3553 return rv;
3554 }
3555 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3556 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return;
3559 }
3560 buffer copy = (buffer)malloc(DATASIZE);
3561 if (copy == NULL) {
3562 wxPyBLOCK_THREADS(PyErr_NoMemory());
3563 return;
3564 }
3565 memcpy(copy, data, DATASIZE);
3566 self->SetData(copy, false);
3567 // wxImage takes ownership of copy...
3568 }
3569 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3570 buffer data = self->GetData();
3571 int len = self->GetWidth() * self->GetHeight() * 3;
3572 PyObject* rv;
3573 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3574 return rv;
3575 }
3576 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3577 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3578 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3579 return;
3580 }
3581 self->SetData(data, true);
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 if (! data) {
3586 RETURN_NONE();
3587 } else {
3588 int len = self->GetWidth() * self->GetHeight();
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3591 return rv;
3592 }
3593 }
3594 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3595 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3596 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3597 return;
3598 }
3599 buffer acopy = (buffer)malloc(ALPHASIZE);
3600 if (acopy == NULL) {
3601 wxPyBLOCK_THREADS(PyErr_NoMemory());
3602 return;
3603 }
3604 memcpy(acopy, alpha, ALPHASIZE);
3605 self->SetAlpha(acopy, false);
3606 // wxImage takes ownership of acopy...
3607 }
3608 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3609 buffer data = self->GetAlpha();
3610 int len = self->GetWidth() * self->GetHeight();
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3616 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3618 return;
3619 }
3620 self->SetAlpha(alpha, true);
3621 }
3622 SWIGINTERN PyObject *wxImage_GetHandlers(){
3623 wxList& list = wxImage::GetHandlers();
3624 return wxPy_ConvertList(&list);
3625 }
3626 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3627 wxBitmap bitmap(*self, depth);
3628 return bitmap;
3629 }
3630 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3631 wxImage mono = self->ConvertToMono( red, green, blue );
3632 wxBitmap bitmap( mono, 1 );
3633 return bitmap;
3634 }
3635 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3636 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3638 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3642 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3643 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3644 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3645 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3646 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3647 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3648 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3649 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3650
3651 #include <wx/quantize.h>
3652
3653 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3654 return wxQuantize::Quantize(src, dest,
3655 //NULL, // palette
3656 desiredNoColours,
3657 NULL, // eightBitData
3658 flags);
3659 }
3660 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3661 if (PyCallable_Check(func)) {
3662 self->Connect(id, lastId, eventType,
3663 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3664 new wxPyCallback(func));
3665 }
3666 else if (func == Py_None) {
3667 self->Disconnect(id, lastId, eventType,
3668 (wxObjectEventFunction)
3669 &wxPyCallback::EventThunker);
3670 }
3671 else {
3672 wxPyBLOCK_THREADS(
3673 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3674 }
3675 }
3676 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3677 return self->Disconnect(id, lastId, eventType,
3678 (wxObjectEventFunction)
3679 &wxPyCallback::EventThunker);
3680 }
3681 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3682 if (_self && _self != Py_None) {
3683 self->SetClientObject(new wxPyOORClientData(_self, incref));
3684 }
3685 else {
3686 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3687 if (data) {
3688 self->SetClientObject(NULL); // This will delete it too
3689 }
3690 }
3691 }
3692
3693 #if ! wxUSE_HOTKEY
3694 #define wxEVT_HOTKEY -9999
3695 #endif
3696
3697 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3698 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3699 if (data) {
3700 Py_INCREF(data->m_obj);
3701 return data->m_obj;
3702 } else {
3703 Py_INCREF(Py_None);
3704 return Py_None;
3705 }
3706 }
3707 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3708 wxPyClientData* data = new wxPyClientData(clientData);
3709 self->SetClientObject(data);
3710 }
3711 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3712 #if wxUSE_UNICODE
3713 return self->GetUnicodeKey();
3714 #else
3715 return 0;
3716 #endif
3717 }
3718 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3719 #if wxUSE_UNICODE
3720 self->m_uniChar = uniChar;
3721 #endif
3722 }
3723
3724 SWIGINTERNINLINE PyObject *
3725 SWIG_From_unsigned_SS_int (unsigned int value)
3726 {
3727 return SWIG_From_unsigned_SS_long (value);
3728 }
3729
3730
3731 SWIGINTERN int
3732 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3733 {
3734 unsigned long v;
3735 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3736 if (SWIG_IsOK(res)) {
3737 if ((v > UINT_MAX)) {
3738 return SWIG_OverflowError;
3739 } else {
3740 if (val) *val = static_cast< unsigned int >(v);
3741 }
3742 }
3743 return res;
3744 }
3745
3746 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3747 self->m_size = size;
3748 }
3749 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3750 int count = self->GetNumberOfFiles();
3751 wxString* files = self->GetFiles();
3752 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3753 PyObject* list = PyList_New(count);
3754
3755 if (!list) {
3756 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3757 wxPyEndBlockThreads(blocked);
3758 return NULL;
3759 }
3760
3761 for (int i=0; i<count; i++) {
3762 PyList_SetItem(list, i, wx2PyString(files[i]));
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return list;
3766 }
3767
3768
3769 SWIGINTERN wxPyApp *new_wxPyApp(){
3770 wxPythonApp = new wxPyApp();
3771 return wxPythonApp;
3772 }
3773
3774 void wxApp_CleanUp() {
3775 __wxPyCleanup();
3776 }
3777
3778
3779 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3780
3781
3782
3783
3784
3785 SWIGINTERNINLINE PyObject *
3786 SWIG_FromCharPtr(const char *cptr)
3787 {
3788 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3789 }
3790
3791
3792 #if 0 // #ifdef __WXMAC__
3793
3794 // A dummy class that raises an exception if used...
3795 class wxEventLoop
3796 {
3797 public:
3798 wxEventLoop() { wxPyRaiseNotImplemented(); }
3799 int Run() { return 0; }
3800 void Exit(int rc = 0) {}
3801 bool Pending() const { return false; }
3802 bool Dispatch() { return false; }
3803 bool IsRunning() const { return false; }
3804 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3805 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3806 };
3807
3808 #else
3809
3810 #include <wx/evtloop.h>
3811
3812 #endif
3813
3814
3815
3816 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3817 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3818 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3819 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3820 wxWindowList& list = self->GetChildren();
3821 return wxPy_ConvertList(&list);
3822 }
3823 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3824 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3825 #if wxUSE_HOTKEY
3826 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3827 #else
3828 return false;
3829 #endif
3830 }
3831 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3832
3833
3834
3835 return false;
3836
3837 }
3838 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3839 return wxPyGetWinHandle(self);
3840 }
3841 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3842 self->AssociateHandle((WXWidget)handle);
3843 }
3844
3845 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3846 return wxWindow::FindWindowById(id, parent);
3847 }
3848
3849 wxWindow* wxFindWindowByName( const wxString& name,
3850 const wxWindow *parent = NULL ) {
3851 return wxWindow::FindWindowByName(name, parent);
3852 }
3853
3854 wxWindow* wxFindWindowByLabel( const wxString& label,
3855 const wxWindow *parent = NULL ) {
3856 return wxWindow::FindWindowByLabel(label, parent);
3857 }
3858
3859
3860 #ifdef __WXMSW__
3861 #include <wx/msw/private.h> // to get wxGetWindowId
3862 #endif
3863
3864
3865 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3866 #ifdef __WXMSW__
3867 WXHWND hWnd = (WXHWND)_hWnd;
3868 long id = wxGetWindowId(hWnd);
3869 wxWindow* win = new wxWindow;
3870 if (parent)
3871 parent->AddChild(win);
3872 win->SetEventHandler(win);
3873 win->SetHWND(hWnd);
3874 win->SetId(id);
3875 win->SubclassWin(hWnd);
3876 win->AdoptAttributesFromHWND();
3877 win->SetupColours();
3878 return win;
3879 #else
3880 wxPyRaiseNotImplemented();
3881 return NULL;
3882 #endif
3883 }
3884
3885
3886 PyObject* GetTopLevelWindows() {
3887 return wxPy_ConvertList(&wxTopLevelWindows);
3888 }
3889
3890
3891 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3892 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3893 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3894
3895 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3896
3897
3898 SWIGINTERNINLINE int
3899 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3900 {
3901 unsigned long v;
3902 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3903 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3904 return res;
3905 }
3906
3907 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3908 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3909 wxMenuItemList& list = self->GetMenuItems();
3910 return wxPy_ConvertList(&list);
3911 }
3912 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3913 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3914 static const wxString wxPyControlNameStr(wxControlNameStr);
3915 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3916 if (clientData) {
3917 wxPyClientData* data = new wxPyClientData(clientData);
3918 return self->Append(item, data);
3919 } else
3920 return self->Append(item);
3921 }
3922 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3923 if (clientData) {
3924 wxPyClientData* data = new wxPyClientData(clientData);
3925 return self->Insert(item, pos, data);
3926 } else
3927 return self->Insert(item, pos);
3928 }
3929 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3930 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3931 if (data) {
3932 Py_INCREF(data->m_obj);
3933 return data->m_obj;
3934 } else {
3935 Py_INCREF(Py_None);
3936 return Py_None;
3937 }
3938 }
3939 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3940 wxPyClientData* data = new wxPyClientData(clientData);
3941 self->SetClientObject(n, data);
3942 }
3943
3944
3945 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3946 wxPyUserData* data = NULL;
3947 if ( userData ) {
3948 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3949 data = new wxPyUserData(userData);
3950 wxPyEndBlockThreads(blocked);
3951 }
3952 return new wxSizerItem(window, proportion, flag, border, data);
3953 }
3954 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3955 wxPyUserData* data = NULL;
3956 if ( userData ) {
3957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3958 data = new wxPyUserData(userData);
3959 wxPyEndBlockThreads(blocked);
3960 }
3961 return new wxSizerItem(width, height, proportion, flag, border, data);
3962 }
3963 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3964 wxPyUserData* data = NULL;
3965 if ( userData ) {
3966 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3967 data = new wxPyUserData(userData);
3968 wxPyEndBlockThreads(blocked);
3969 }
3970 return new wxSizerItem(sizer, proportion, flag, border, data);
3971 }
3972
3973 SWIGINTERNINLINE PyObject *
3974 SWIG_From_float (float value)
3975 {
3976 return SWIG_From_double (value);
3977 }
3978
3979 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3980 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3981 if (data) {
3982 Py_INCREF(data->m_obj);
3983 return data->m_obj;
3984 } else {
3985 Py_INCREF(Py_None);
3986 return Py_None;
3987 }
3988 }
3989 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 self->SetUserData(data);
3997 }
3998
3999 // Figure out the type of the sizer item
4000
4001 struct wxPySizerItemInfo {
4002 wxPySizerItemInfo()
4003 : window(NULL), sizer(NULL), gotSize(false),
4004 size(wxDefaultSize), gotPos(false), pos(-1)
4005 {}
4006
4007 wxWindow* window;
4008 wxSizer* sizer;
4009 bool gotSize;
4010 wxSize size;
4011 bool gotPos;
4012 int pos;
4013 };
4014
4015 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4016
4017 wxPySizerItemInfo info;
4018 wxSize size;
4019 wxSize* sizePtr = &size;
4020
4021 // Find out what the type of the item is
4022 // try wxWindow
4023 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4024 PyErr_Clear();
4025 info.window = NULL;
4026
4027 // try wxSizer
4028 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4029 PyErr_Clear();
4030 info.sizer = NULL;
4031
4032 // try wxSize or (w,h)
4033 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4034 info.size = *sizePtr;
4035 info.gotSize = true;
4036 }
4037
4038 // or a single int
4039 if (checkIdx && PyInt_Check(item)) {
4040 info.pos = PyInt_AsLong(item);
4041 info.gotPos = true;
4042 }
4043 }
4044 }
4045
4046 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4047 // no expected type, figure out what kind of error message to generate
4048 if ( !checkSize && !checkIdx )
4049 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4050 else if ( checkSize && !checkIdx )
4051 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4052 else if ( !checkSize && checkIdx)
4053 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4054 else
4055 // can this one happen?
4056 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4057 }
4058
4059 return info;
4060 }
4061
4062 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4063 if (!self->GetClientObject())
4064 self->SetClientObject(new wxPyOORClientData(_self));
4065 }
4066 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4067
4068 wxPyUserData* data = NULL;
4069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4070 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4071 if ( userData && (info.window || info.sizer || info.gotSize) )
4072 data = new wxPyUserData(userData);
4073 if ( info.sizer )
4074 PyObject_SetAttrString(item,"thisown",Py_False);
4075 wxPyEndBlockThreads(blocked);
4076
4077 // Now call the real Add method if a valid item type was found
4078 if ( info.window )
4079 return self->Add(info.window, proportion, flag, border, data);
4080 else if ( info.sizer )
4081 return self->Add(info.sizer, proportion, flag, border, data);
4082 else if (info.gotSize)
4083 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4084 proportion, flag, border, data);
4085 else
4086 return NULL;
4087 }
4088 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4089
4090 wxPyUserData* data = NULL;
4091 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4092 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4093 if ( userData && (info.window || info.sizer || info.gotSize) )
4094 data = new wxPyUserData(userData);
4095 if ( info.sizer )
4096 PyObject_SetAttrString(item,"thisown",Py_False);
4097 wxPyEndBlockThreads(blocked);
4098
4099 // Now call the real Insert method if a valid item type was found
4100 if ( info.window )
4101 return self->Insert(before, info.window, proportion, flag, border, data);
4102 else if ( info.sizer )
4103 return self->Insert(before, info.sizer, proportion, flag, border, data);
4104 else if (info.gotSize)
4105 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4106 proportion, flag, border, data);
4107 else
4108 return NULL;
4109 }
4110 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4111
4112 wxPyUserData* data = NULL;
4113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4115 if ( userData && (info.window || info.sizer || info.gotSize) )
4116 data = new wxPyUserData(userData);
4117 if ( info.sizer )
4118 PyObject_SetAttrString(item,"thisown",Py_False);
4119 wxPyEndBlockThreads(blocked);
4120
4121 // Now call the real Prepend method if a valid item type was found
4122 if ( info.window )
4123 return self->Prepend(info.window, proportion, flag, border, data);
4124 else if ( info.sizer )
4125 return self->Prepend(info.sizer, proportion, flag, border, data);
4126 else if (info.gotSize)
4127 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4128 proportion, flag, border, data);
4129 else
4130 return NULL;
4131 }
4132 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4133 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4134 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4135 wxPyEndBlockThreads(blocked);
4136 if ( info.window )
4137 return self->Remove(info.window);
4138 else if ( info.sizer )
4139 return self->Remove(info.sizer);
4140 else if ( info.gotPos )
4141 return self->Remove(info.pos);
4142 else
4143 return false;
4144 }
4145 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4146 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4147 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4148 wxPyEndBlockThreads(blocked);
4149 if ( info.window )
4150 return self->Detach(info.window);
4151 else if ( info.sizer )
4152 return self->Detach(info.sizer);
4153 else if ( info.gotPos )
4154 return self->Detach(info.pos);
4155 else
4156 return false;
4157 }
4158 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4159 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4160 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4161 wxPyEndBlockThreads(blocked);
4162 if ( info.window )
4163 return self->GetItem(info.window);
4164 else if ( info.sizer )
4165 return self->GetItem(info.sizer);
4166 else if ( info.gotPos )
4167 return self->GetItem(info.pos);
4168 else
4169 return NULL;
4170 }
4171 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4173 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4174 wxPyEndBlockThreads(blocked);
4175 if ( info.window )
4176 self->SetItemMinSize(info.window, size);
4177 else if ( info.sizer )
4178 self->SetItemMinSize(info.sizer, size);
4179 else if ( info.gotPos )
4180 self->SetItemMinSize(info.pos, size);
4181 }
4182 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4183 wxSizerItemList& list = self->GetChildren();
4184 return wxPy_ConvertList(&list);
4185 }
4186 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4189 wxPyEndBlockThreads(blocked);
4190 if ( info.window )
4191 return self->Show(info.window, show, recursive);
4192 else if ( info.sizer )
4193 return self->Show(info.sizer, show, recursive);
4194 else if ( info.gotPos )
4195 return self->Show(info.pos, show);
4196 else
4197 return false;
4198 }
4199 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4201 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4202 wxPyEndBlockThreads(blocked);
4203 if ( info.window )
4204 return self->IsShown(info.window);
4205 else if ( info.sizer )
4206 return self->IsShown(info.sizer);
4207 else if ( info.gotPos )
4208 return self->IsShown(info.pos);
4209 else
4210 return false;
4211 }
4212
4213 // See pyclasses.h
4214 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4215 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4216 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4217
4218
4219
4220
4221 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4222 {
4223 if (source == Py_None) {
4224 **obj = wxGBPosition(-1,-1);
4225 return true;
4226 }
4227 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4228 }
4229
4230 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4231 {
4232 if (source == Py_None) {
4233 **obj = wxGBSpan(-1,-1);
4234 return true;
4235 }
4236 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4237 }
4238
4239
4240 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4241 wxGBPosition temp, *obj = &temp;
4242 if ( other == Py_None ) return false;
4243 if ( ! wxGBPosition_helper(other, &obj) ) {
4244 PyErr_Clear();
4245 return false;
4246 }
4247 return self->operator==(*obj);
4248 }
4249 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4250 wxGBPosition temp, *obj = &temp;
4251 if ( other == Py_None ) return true;
4252 if ( ! wxGBPosition_helper(other, &obj)) {
4253 PyErr_Clear();
4254 return true;
4255 }
4256 return self->operator!=(*obj);
4257 }
4258 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4259 self->SetRow(row);
4260 self->SetCol(col);
4261 }
4262 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4264 PyObject* tup = PyTuple_New(2);
4265 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4266 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4267 wxPyEndBlockThreads(blocked);
4268 return tup;
4269 }
4270 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4271 wxGBSpan temp, *obj = &temp;
4272 if ( other == Py_None ) return false;
4273 if ( ! wxGBSpan_helper(other, &obj) ) {
4274 PyErr_Clear();
4275 return false;
4276 }
4277 return self->operator==(*obj);
4278 }
4279 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4280 wxGBSpan temp, *obj = &temp;
4281 if ( other == Py_None ) return true;
4282 if ( ! wxGBSpan_helper(other, &obj)) {
4283 PyErr_Clear();
4284 return true;
4285 }
4286 return self->operator!=(*obj);
4287 }
4288 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4289 self->SetRowspan(rowspan);
4290 self->SetColspan(colspan);
4291 }
4292 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4294 PyObject* tup = PyTuple_New(2);
4295 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4296 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4297 wxPyEndBlockThreads(blocked);
4298 return tup;
4299 }
4300 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4301 wxPyUserData* data = NULL;
4302 if ( userData ) {
4303 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4304 data = new wxPyUserData(userData);
4305 wxPyEndBlockThreads(blocked);
4306 }
4307 return new wxGBSizerItem(window, pos, span, flag, border, data);
4308 }
4309 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4310 wxPyUserData* data = NULL;
4311 if ( userData ) {
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 data = new wxPyUserData(userData);
4314 wxPyEndBlockThreads(blocked);
4315 }
4316 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4317 }
4318 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4319 wxPyUserData* data = NULL;
4320 if ( userData ) {
4321 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4322 data = new wxPyUserData(userData);
4323 wxPyEndBlockThreads(blocked);
4324 }
4325 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4326 }
4327 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4328 int row, col;
4329 self->GetEndPos(row, col);
4330 return wxGBPosition(row, col);
4331 }
4332 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4333
4334 wxPyUserData* data = NULL;
4335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4336 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4337 if ( userData && (info.window || info.sizer || info.gotSize) )
4338 data = new wxPyUserData(userData);
4339 if ( info.sizer )
4340 PyObject_SetAttrString(item,"thisown",Py_False);
4341 wxPyEndBlockThreads(blocked);
4342
4343 // Now call the real Add method if a valid item type was found
4344 if ( info.window )
4345 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4346 else if ( info.sizer )
4347 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4348 else if (info.gotSize)
4349 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4350 pos, span, flag, border, data);
4351 return NULL;
4352 }
4353
4354
4355 #ifdef __cplusplus
4356 extern "C" {
4357 #endif
4358 SWIGINTERN int EmptyString_set(PyObject *) {
4359 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4360 return 1;
4361 }
4362
4363
4364 SWIGINTERN PyObject *EmptyString_get(void) {
4365 PyObject *pyobj = 0;
4366
4367 {
4368 #if wxUSE_UNICODE
4369 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4370 #else
4371 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4372 #endif
4373 }
4374 return pyobj;
4375 }
4376
4377
4378 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4379 PyObject *resultobj = 0;
4380 wxObject *arg1 = (wxObject *) 0 ;
4381 wxString result;
4382 void *argp1 = 0 ;
4383 int res1 = 0 ;
4384 PyObject *swig_obj[1] ;
4385
4386 if (!args) SWIG_fail;
4387 swig_obj[0] = args;
4388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4389 if (!SWIG_IsOK(res1)) {
4390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4391 }
4392 arg1 = reinterpret_cast< wxObject * >(argp1);
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = wxObject_GetClassName(arg1);
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 {
4400 #if wxUSE_UNICODE
4401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4402 #else
4403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4404 #endif
4405 }
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxObject *arg1 = (wxObject *) 0 ;
4415 void *argp1 = 0 ;
4416 int res1 = 0 ;
4417 PyObject *swig_obj[1] ;
4418
4419 if (!args) SWIG_fail;
4420 swig_obj[0] = args;
4421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4422 if (!SWIG_IsOK(res1)) {
4423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4424 }
4425 arg1 = reinterpret_cast< wxObject * >(argp1);
4426 {
4427 PyThreadState* __tstate = wxPyBeginAllowThreads();
4428 wxObject_Destroy(arg1);
4429 wxPyEndAllowThreads(__tstate);
4430 if (PyErr_Occurred()) SWIG_fail;
4431 }
4432 resultobj = SWIG_Py_Void();
4433 return resultobj;
4434 fail:
4435 return NULL;
4436 }
4437
4438
4439 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4440 PyObject *obj;
4441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4442 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4443 return SWIG_Py_Void();
4444 }
4445
4446 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447 PyObject *resultobj = 0;
4448 wxSize *arg1 = (wxSize *) 0 ;
4449 int arg2 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 int val2 ;
4453 int ecode2 = 0 ;
4454 PyObject *swig_obj[2] ;
4455
4456 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4460 }
4461 arg1 = reinterpret_cast< wxSize * >(argp1);
4462 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4463 if (!SWIG_IsOK(ecode2)) {
4464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4465 }
4466 arg2 = static_cast< int >(val2);
4467 if (arg1) (arg1)->x = arg2;
4468
4469 resultobj = SWIG_Py_Void();
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 PyObject *resultobj = 0;
4478 wxSize *arg1 = (wxSize *) 0 ;
4479 int result;
4480 void *argp1 = 0 ;
4481 int res1 = 0 ;
4482 PyObject *swig_obj[1] ;
4483
4484 if (!args) SWIG_fail;
4485 swig_obj[0] = args;
4486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4487 if (!SWIG_IsOK(res1)) {
4488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4489 }
4490 arg1 = reinterpret_cast< wxSize * >(argp1);
4491 result = (int) ((arg1)->x);
4492 resultobj = SWIG_From_int(static_cast< int >(result));
4493 return resultobj;
4494 fail:
4495 return NULL;
4496 }
4497
4498
4499 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4500 PyObject *resultobj = 0;
4501 wxSize *arg1 = (wxSize *) 0 ;
4502 int arg2 ;
4503 void *argp1 = 0 ;
4504 int res1 = 0 ;
4505 int val2 ;
4506 int ecode2 = 0 ;
4507 PyObject *swig_obj[2] ;
4508
4509 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4511 if (!SWIG_IsOK(res1)) {
4512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4513 }
4514 arg1 = reinterpret_cast< wxSize * >(argp1);
4515 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4516 if (!SWIG_IsOK(ecode2)) {
4517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4518 }
4519 arg2 = static_cast< int >(val2);
4520 if (arg1) (arg1)->y = arg2;
4521
4522 resultobj = SWIG_Py_Void();
4523 return resultobj;
4524 fail:
4525 return NULL;
4526 }
4527
4528
4529 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4530 PyObject *resultobj = 0;
4531 wxSize *arg1 = (wxSize *) 0 ;
4532 int result;
4533 void *argp1 = 0 ;
4534 int res1 = 0 ;
4535 PyObject *swig_obj[1] ;
4536
4537 if (!args) SWIG_fail;
4538 swig_obj[0] = args;
4539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4540 if (!SWIG_IsOK(res1)) {
4541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4542 }
4543 arg1 = reinterpret_cast< wxSize * >(argp1);
4544 result = (int) ((arg1)->y);
4545 resultobj = SWIG_From_int(static_cast< int >(result));
4546 return resultobj;
4547 fail:
4548 return NULL;
4549 }
4550
4551
4552 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4553 PyObject *resultobj = 0;
4554 int arg1 = (int) 0 ;
4555 int arg2 = (int) 0 ;
4556 wxSize *result = 0 ;
4557 int val1 ;
4558 int ecode1 = 0 ;
4559 int val2 ;
4560 int ecode2 = 0 ;
4561 PyObject * obj0 = 0 ;
4562 PyObject * obj1 = 0 ;
4563 char * kwnames[] = {
4564 (char *) "w",(char *) "h", NULL
4565 };
4566
4567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4568 if (obj0) {
4569 ecode1 = SWIG_AsVal_int(obj0, &val1);
4570 if (!SWIG_IsOK(ecode1)) {
4571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4572 }
4573 arg1 = static_cast< int >(val1);
4574 }
4575 if (obj1) {
4576 ecode2 = SWIG_AsVal_int(obj1, &val2);
4577 if (!SWIG_IsOK(ecode2)) {
4578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4579 }
4580 arg2 = static_cast< int >(val2);
4581 }
4582 {
4583 PyThreadState* __tstate = wxPyBeginAllowThreads();
4584 result = (wxSize *)new wxSize(arg1,arg2);
4585 wxPyEndAllowThreads(__tstate);
4586 if (PyErr_Occurred()) SWIG_fail;
4587 }
4588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596 PyObject *resultobj = 0;
4597 wxSize *arg1 = (wxSize *) 0 ;
4598 void *argp1 = 0 ;
4599 int res1 = 0 ;
4600 PyObject *swig_obj[1] ;
4601
4602 if (!args) SWIG_fail;
4603 swig_obj[0] = args;
4604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4605 if (!SWIG_IsOK(res1)) {
4606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4607 }
4608 arg1 = reinterpret_cast< wxSize * >(argp1);
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 delete arg1;
4612
4613 wxPyEndAllowThreads(__tstate);
4614 if (PyErr_Occurred()) SWIG_fail;
4615 }
4616 resultobj = SWIG_Py_Void();
4617 return resultobj;
4618 fail:
4619 return NULL;
4620 }
4621
4622
4623 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4624 PyObject *resultobj = 0;
4625 wxSize *arg1 = (wxSize *) 0 ;
4626 PyObject *arg2 = (PyObject *) 0 ;
4627 bool result;
4628 void *argp1 = 0 ;
4629 int res1 = 0 ;
4630 PyObject * obj0 = 0 ;
4631 PyObject * obj1 = 0 ;
4632 char * kwnames[] = {
4633 (char *) "self",(char *) "other", NULL
4634 };
4635
4636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4638 if (!SWIG_IsOK(res1)) {
4639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4640 }
4641 arg1 = reinterpret_cast< wxSize * >(argp1);
4642 arg2 = obj1;
4643 {
4644 result = (bool)wxSize___eq__(arg1,arg2);
4645 if (PyErr_Occurred()) SWIG_fail;
4646 }
4647 {
4648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4649 }
4650 return resultobj;
4651 fail:
4652 return NULL;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4657 PyObject *resultobj = 0;
4658 wxSize *arg1 = (wxSize *) 0 ;
4659 PyObject *arg2 = (PyObject *) 0 ;
4660 bool result;
4661 void *argp1 = 0 ;
4662 int res1 = 0 ;
4663 PyObject * obj0 = 0 ;
4664 PyObject * obj1 = 0 ;
4665 char * kwnames[] = {
4666 (char *) "self",(char *) "other", NULL
4667 };
4668
4669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4671 if (!SWIG_IsOK(res1)) {
4672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4673 }
4674 arg1 = reinterpret_cast< wxSize * >(argp1);
4675 arg2 = obj1;
4676 {
4677 result = (bool)wxSize___ne__(arg1,arg2);
4678 if (PyErr_Occurred()) SWIG_fail;
4679 }
4680 {
4681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4682 }
4683 return resultobj;
4684 fail:
4685 return NULL;
4686 }
4687
4688
4689 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4690 PyObject *resultobj = 0;
4691 wxSize *arg1 = (wxSize *) 0 ;
4692 wxSize *arg2 = 0 ;
4693 wxSize result;
4694 void *argp1 = 0 ;
4695 int res1 = 0 ;
4696 wxSize temp2 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "self",(char *) "sz", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4705 if (!SWIG_IsOK(res1)) {
4706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4707 }
4708 arg1 = reinterpret_cast< wxSize * >(argp1);
4709 {
4710 arg2 = &temp2;
4711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4712 }
4713 {
4714 PyThreadState* __tstate = wxPyBeginAllowThreads();
4715 result = (arg1)->operator +((wxSize const &)*arg2);
4716 wxPyEndAllowThreads(__tstate);
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 wxSize *arg2 = 0 ;
4730 wxSize result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 wxSize temp2 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "sz", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 {
4747 arg2 = &temp2;
4748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4749 }
4750 {
4751 PyThreadState* __tstate = wxPyBeginAllowThreads();
4752 result = (arg1)->operator -((wxSize const &)*arg2);
4753 wxPyEndAllowThreads(__tstate);
4754 if (PyErr_Occurred()) SWIG_fail;
4755 }
4756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4757 return resultobj;
4758 fail:
4759 return NULL;
4760 }
4761
4762
4763 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj = 0;
4765 wxSize *arg1 = (wxSize *) 0 ;
4766 wxSize *arg2 = 0 ;
4767 void *argp1 = 0 ;
4768 int res1 = 0 ;
4769 wxSize temp2 ;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 char * kwnames[] = {
4773 (char *) "self",(char *) "sz", NULL
4774 };
4775
4776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4778 if (!SWIG_IsOK(res1)) {
4779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4780 }
4781 arg1 = reinterpret_cast< wxSize * >(argp1);
4782 {
4783 arg2 = &temp2;
4784 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 (arg1)->IncTo((wxSize const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 resultobj = SWIG_Py_Void();
4793 return resultobj;
4794 fail:
4795 return NULL;
4796 }
4797
4798
4799 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4800 PyObject *resultobj = 0;
4801 wxSize *arg1 = (wxSize *) 0 ;
4802 wxSize *arg2 = 0 ;
4803 void *argp1 = 0 ;
4804 int res1 = 0 ;
4805 wxSize temp2 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "self",(char *) "sz", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4814 if (!SWIG_IsOK(res1)) {
4815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4816 }
4817 arg1 = reinterpret_cast< wxSize * >(argp1);
4818 {
4819 arg2 = &temp2;
4820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 (arg1)->DecTo((wxSize const &)*arg2);
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 resultobj = SWIG_Py_Void();
4829 return resultobj;
4830 fail:
4831 return NULL;
4832 }
4833
4834
4835 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4836 PyObject *resultobj = 0;
4837 wxSize *arg1 = (wxSize *) 0 ;
4838 float arg2 ;
4839 float arg3 ;
4840 void *argp1 = 0 ;
4841 int res1 = 0 ;
4842 float val2 ;
4843 int ecode2 = 0 ;
4844 float val3 ;
4845 int ecode3 = 0 ;
4846 PyObject * obj0 = 0 ;
4847 PyObject * obj1 = 0 ;
4848 PyObject * obj2 = 0 ;
4849 char * kwnames[] = {
4850 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4851 };
4852
4853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4855 if (!SWIG_IsOK(res1)) {
4856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4857 }
4858 arg1 = reinterpret_cast< wxSize * >(argp1);
4859 ecode2 = SWIG_AsVal_float(obj1, &val2);
4860 if (!SWIG_IsOK(ecode2)) {
4861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4862 }
4863 arg2 = static_cast< float >(val2);
4864 ecode3 = SWIG_AsVal_float(obj2, &val3);
4865 if (!SWIG_IsOK(ecode3)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4867 }
4868 arg3 = static_cast< float >(val3);
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 (arg1)->Scale(arg2,arg3);
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 resultobj = SWIG_Py_Void();
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 wxSize *arg1 = (wxSize *) 0 ;
4885 int arg2 ;
4886 int arg3 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 int val2 ;
4890 int ecode2 = 0 ;
4891 int val3 ;
4892 int ecode3 = 0 ;
4893 PyObject * obj0 = 0 ;
4894 PyObject * obj1 = 0 ;
4895 PyObject * obj2 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "self",(char *) "w",(char *) "h", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4902 if (!SWIG_IsOK(res1)) {
4903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4904 }
4905 arg1 = reinterpret_cast< wxSize * >(argp1);
4906 ecode2 = SWIG_AsVal_int(obj1, &val2);
4907 if (!SWIG_IsOK(ecode2)) {
4908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4909 }
4910 arg2 = static_cast< int >(val2);
4911 ecode3 = SWIG_AsVal_int(obj2, &val3);
4912 if (!SWIG_IsOK(ecode3)) {
4913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4914 }
4915 arg3 = static_cast< int >(val3);
4916 {
4917 PyThreadState* __tstate = wxPyBeginAllowThreads();
4918 (arg1)->Set(arg2,arg3);
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 resultobj = SWIG_Py_Void();
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj = 0;
4931 wxSize *arg1 = (wxSize *) 0 ;
4932 int arg2 ;
4933 void *argp1 = 0 ;
4934 int res1 = 0 ;
4935 int val2 ;
4936 int ecode2 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 char * kwnames[] = {
4940 (char *) "self",(char *) "w", NULL
4941 };
4942
4943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4945 if (!SWIG_IsOK(res1)) {
4946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4947 }
4948 arg1 = reinterpret_cast< wxSize * >(argp1);
4949 ecode2 = SWIG_AsVal_int(obj1, &val2);
4950 if (!SWIG_IsOK(ecode2)) {
4951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4952 }
4953 arg2 = static_cast< int >(val2);
4954 {
4955 PyThreadState* __tstate = wxPyBeginAllowThreads();
4956 (arg1)->SetWidth(arg2);
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 resultobj = SWIG_Py_Void();
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj = 0;
4969 wxSize *arg1 = (wxSize *) 0 ;
4970 int arg2 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 int val2 ;
4974 int ecode2 = 0 ;
4975 PyObject * obj0 = 0 ;
4976 PyObject * obj1 = 0 ;
4977 char * kwnames[] = {
4978 (char *) "self",(char *) "h", NULL
4979 };
4980
4981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4983 if (!SWIG_IsOK(res1)) {
4984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4985 }
4986 arg1 = reinterpret_cast< wxSize * >(argp1);
4987 ecode2 = SWIG_AsVal_int(obj1, &val2);
4988 if (!SWIG_IsOK(ecode2)) {
4989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4990 }
4991 arg2 = static_cast< int >(val2);
4992 {
4993 PyThreadState* __tstate = wxPyBeginAllowThreads();
4994 (arg1)->SetHeight(arg2);
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 resultobj = SWIG_Py_Void();
4999 return resultobj;
5000 fail:
5001 return NULL;
5002 }
5003
5004
5005 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5006 PyObject *resultobj = 0;
5007 wxSize *arg1 = (wxSize *) 0 ;
5008 int result;
5009 void *argp1 = 0 ;
5010 int res1 = 0 ;
5011 PyObject *swig_obj[1] ;
5012
5013 if (!args) SWIG_fail;
5014 swig_obj[0] = args;
5015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5016 if (!SWIG_IsOK(res1)) {
5017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5018 }
5019 arg1 = reinterpret_cast< wxSize * >(argp1);
5020 {
5021 PyThreadState* __tstate = wxPyBeginAllowThreads();
5022 result = (int)((wxSize const *)arg1)->GetWidth();
5023 wxPyEndAllowThreads(__tstate);
5024 if (PyErr_Occurred()) SWIG_fail;
5025 }
5026 resultobj = SWIG_From_int(static_cast< int >(result));
5027 return resultobj;
5028 fail:
5029 return NULL;
5030 }
5031
5032
5033 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5034 PyObject *resultobj = 0;
5035 wxSize *arg1 = (wxSize *) 0 ;
5036 int result;
5037 void *argp1 = 0 ;
5038 int res1 = 0 ;
5039 PyObject *swig_obj[1] ;
5040
5041 if (!args) SWIG_fail;
5042 swig_obj[0] = args;
5043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5044 if (!SWIG_IsOK(res1)) {
5045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5046 }
5047 arg1 = reinterpret_cast< wxSize * >(argp1);
5048 {
5049 PyThreadState* __tstate = wxPyBeginAllowThreads();
5050 result = (int)((wxSize const *)arg1)->GetHeight();
5051 wxPyEndAllowThreads(__tstate);
5052 if (PyErr_Occurred()) SWIG_fail;
5053 }
5054 resultobj = SWIG_From_int(static_cast< int >(result));
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxSize *arg1 = (wxSize *) 0 ;
5064 bool result;
5065 void *argp1 = 0 ;
5066 int res1 = 0 ;
5067 PyObject *swig_obj[1] ;
5068
5069 if (!args) SWIG_fail;
5070 swig_obj[0] = args;
5071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5072 if (!SWIG_IsOK(res1)) {
5073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5074 }
5075 arg1 = reinterpret_cast< wxSize * >(argp1);
5076 {
5077 PyThreadState* __tstate = wxPyBeginAllowThreads();
5078 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5079 wxPyEndAllowThreads(__tstate);
5080 if (PyErr_Occurred()) SWIG_fail;
5081 }
5082 {
5083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5084 }
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5092 PyObject *resultobj = 0;
5093 wxSize *arg1 = (wxSize *) 0 ;
5094 wxSize *arg2 = 0 ;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 wxSize temp2 ;
5098 PyObject * obj0 = 0 ;
5099 PyObject * obj1 = 0 ;
5100 char * kwnames[] = {
5101 (char *) "self",(char *) "size", NULL
5102 };
5103
5104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5106 if (!SWIG_IsOK(res1)) {
5107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5108 }
5109 arg1 = reinterpret_cast< wxSize * >(argp1);
5110 {
5111 arg2 = &temp2;
5112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5113 }
5114 {
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 (arg1)->SetDefaults((wxSize const &)*arg2);
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 resultobj = SWIG_Py_Void();
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5128 PyObject *resultobj = 0;
5129 wxSize *arg1 = (wxSize *) 0 ;
5130 PyObject *result = 0 ;
5131 void *argp1 = 0 ;
5132 int res1 = 0 ;
5133 PyObject *swig_obj[1] ;
5134
5135 if (!args) SWIG_fail;
5136 swig_obj[0] = args;
5137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5138 if (!SWIG_IsOK(res1)) {
5139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5140 }
5141 arg1 = reinterpret_cast< wxSize * >(argp1);
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 result = (PyObject *)wxSize_Get(arg1);
5145 wxPyEndAllowThreads(__tstate);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 resultobj = result;
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5156 PyObject *obj;
5157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5158 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5159 return SWIG_Py_Void();
5160 }
5161
5162 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 return SWIG_Python_InitShadowInstance(args);
5164 }
5165
5166 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5167 PyObject *resultobj = 0;
5168 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5169 double arg2 ;
5170 void *argp1 = 0 ;
5171 int res1 = 0 ;
5172 double val2 ;
5173 int ecode2 = 0 ;
5174 PyObject *swig_obj[2] ;
5175
5176 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5180 }
5181 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5182 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5183 if (!SWIG_IsOK(ecode2)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5185 }
5186 arg2 = static_cast< double >(val2);
5187 if (arg1) (arg1)->x = arg2;
5188
5189 resultobj = SWIG_Py_Void();
5190 return resultobj;
5191 fail:
5192 return NULL;
5193 }
5194
5195
5196 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5197 PyObject *resultobj = 0;
5198 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5199 double result;
5200 void *argp1 = 0 ;
5201 int res1 = 0 ;
5202 PyObject *swig_obj[1] ;
5203
5204 if (!args) SWIG_fail;
5205 swig_obj[0] = args;
5206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5207 if (!SWIG_IsOK(res1)) {
5208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5209 }
5210 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5211 result = (double) ((arg1)->x);
5212 resultobj = SWIG_From_double(static_cast< double >(result));
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5220 PyObject *resultobj = 0;
5221 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5222 double arg2 ;
5223 void *argp1 = 0 ;
5224 int res1 = 0 ;
5225 double val2 ;
5226 int ecode2 = 0 ;
5227 PyObject *swig_obj[2] ;
5228
5229 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5231 if (!SWIG_IsOK(res1)) {
5232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5233 }
5234 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5235 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5236 if (!SWIG_IsOK(ecode2)) {
5237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5238 }
5239 arg2 = static_cast< double >(val2);
5240 if (arg1) (arg1)->y = arg2;
5241
5242 resultobj = SWIG_Py_Void();
5243 return resultobj;
5244 fail:
5245 return NULL;
5246 }
5247
5248
5249 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5250 PyObject *resultobj = 0;
5251 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5252 double result;
5253 void *argp1 = 0 ;
5254 int res1 = 0 ;
5255 PyObject *swig_obj[1] ;
5256
5257 if (!args) SWIG_fail;
5258 swig_obj[0] = args;
5259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5260 if (!SWIG_IsOK(res1)) {
5261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5262 }
5263 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5264 result = (double) ((arg1)->y);
5265 resultobj = SWIG_From_double(static_cast< double >(result));
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj = 0;
5274 double arg1 = (double) 0.0 ;
5275 double arg2 = (double) 0.0 ;
5276 wxRealPoint *result = 0 ;
5277 double val1 ;
5278 int ecode1 = 0 ;
5279 double val2 ;
5280 int ecode2 = 0 ;
5281 PyObject * obj0 = 0 ;
5282 PyObject * obj1 = 0 ;
5283 char * kwnames[] = {
5284 (char *) "x",(char *) "y", NULL
5285 };
5286
5287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5288 if (obj0) {
5289 ecode1 = SWIG_AsVal_double(obj0, &val1);
5290 if (!SWIG_IsOK(ecode1)) {
5291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5292 }
5293 arg1 = static_cast< double >(val1);
5294 }
5295 if (obj1) {
5296 ecode2 = SWIG_AsVal_double(obj1, &val2);
5297 if (!SWIG_IsOK(ecode2)) {
5298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5299 }
5300 arg2 = static_cast< double >(val2);
5301 }
5302 {
5303 PyThreadState* __tstate = wxPyBeginAllowThreads();
5304 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5305 wxPyEndAllowThreads(__tstate);
5306 if (PyErr_Occurred()) SWIG_fail;
5307 }
5308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5316 PyObject *resultobj = 0;
5317 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5318 void *argp1 = 0 ;
5319 int res1 = 0 ;
5320 PyObject *swig_obj[1] ;
5321
5322 if (!args) SWIG_fail;
5323 swig_obj[0] = args;
5324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5325 if (!SWIG_IsOK(res1)) {
5326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5327 }
5328 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5329 {
5330 PyThreadState* __tstate = wxPyBeginAllowThreads();
5331 delete arg1;
5332
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 resultobj = SWIG_Py_Void();
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj = 0;
5345 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5346 PyObject *arg2 = (PyObject *) 0 ;
5347 bool result;
5348 void *argp1 = 0 ;
5349 int res1 = 0 ;
5350 PyObject * obj0 = 0 ;
5351 PyObject * obj1 = 0 ;
5352 char * kwnames[] = {
5353 (char *) "self",(char *) "other", NULL
5354 };
5355
5356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5358 if (!SWIG_IsOK(res1)) {
5359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5360 }
5361 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5362 arg2 = obj1;
5363 {
5364 result = (bool)wxRealPoint___eq__(arg1,arg2);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 {
5368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5369 }
5370 return resultobj;
5371 fail:
5372 return NULL;
5373 }
5374
5375
5376 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5377 PyObject *resultobj = 0;
5378 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5379 PyObject *arg2 = (PyObject *) 0 ;
5380 bool result;
5381 void *argp1 = 0 ;
5382 int res1 = 0 ;
5383 PyObject * obj0 = 0 ;
5384 PyObject * obj1 = 0 ;
5385 char * kwnames[] = {
5386 (char *) "self",(char *) "other", NULL
5387 };
5388
5389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5391 if (!SWIG_IsOK(res1)) {
5392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5393 }
5394 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5395 arg2 = obj1;
5396 {
5397 result = (bool)wxRealPoint___ne__(arg1,arg2);
5398 if (PyErr_Occurred()) SWIG_fail;
5399 }
5400 {
5401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5402 }
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj = 0;
5411 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5412 wxRealPoint *arg2 = 0 ;
5413 wxRealPoint result;
5414 void *argp1 = 0 ;
5415 int res1 = 0 ;
5416 wxRealPoint temp2 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "pt", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 {
5430 arg2 = &temp2;
5431 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 wxRealPoint *arg2 = 0 ;
5450 wxRealPoint result;
5451 void *argp1 = 0 ;
5452 int res1 = 0 ;
5453 wxRealPoint temp2 ;
5454 PyObject * obj0 = 0 ;
5455 PyObject * obj1 = 0 ;
5456 char * kwnames[] = {
5457 (char *) "self",(char *) "pt", NULL
5458 };
5459
5460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5462 if (!SWIG_IsOK(res1)) {
5463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5464 }
5465 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5466 {
5467 arg2 = &temp2;
5468 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5469 }
5470 {
5471 PyThreadState* __tstate = wxPyBeginAllowThreads();
5472 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5473 wxPyEndAllowThreads(__tstate);
5474 if (PyErr_Occurred()) SWIG_fail;
5475 }
5476 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5477 return resultobj;
5478 fail:
5479 return NULL;
5480 }
5481
5482
5483 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5484 PyObject *resultobj = 0;
5485 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5486 double arg2 ;
5487 double arg3 ;
5488 void *argp1 = 0 ;
5489 int res1 = 0 ;
5490 double val2 ;
5491 int ecode2 = 0 ;
5492 double val3 ;
5493 int ecode3 = 0 ;
5494 PyObject * obj0 = 0 ;
5495 PyObject * obj1 = 0 ;
5496 PyObject * obj2 = 0 ;
5497 char * kwnames[] = {
5498 (char *) "self",(char *) "x",(char *) "y", NULL
5499 };
5500
5501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5503 if (!SWIG_IsOK(res1)) {
5504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5505 }
5506 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5507 ecode2 = SWIG_AsVal_double(obj1, &val2);
5508 if (!SWIG_IsOK(ecode2)) {
5509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5510 }
5511 arg2 = static_cast< double >(val2);
5512 ecode3 = SWIG_AsVal_double(obj2, &val3);
5513 if (!SWIG_IsOK(ecode3)) {
5514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5515 }
5516 arg3 = static_cast< double >(val3);
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 wxRealPoint_Set(arg1,arg2,arg3);
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 resultobj = SWIG_Py_Void();
5524 return resultobj;
5525 fail:
5526 return NULL;
5527 }
5528
5529
5530 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5531 PyObject *resultobj = 0;
5532 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5533 PyObject *result = 0 ;
5534 void *argp1 = 0 ;
5535 int res1 = 0 ;
5536 PyObject *swig_obj[1] ;
5537
5538 if (!args) SWIG_fail;
5539 swig_obj[0] = args;
5540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5541 if (!SWIG_IsOK(res1)) {
5542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5543 }
5544 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5545 {
5546 PyThreadState* __tstate = wxPyBeginAllowThreads();
5547 result = (PyObject *)wxRealPoint_Get(arg1);
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 resultobj = result;
5552 return resultobj;
5553 fail:
5554 return NULL;
5555 }
5556
5557
5558 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5559 PyObject *obj;
5560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5561 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5562 return SWIG_Py_Void();
5563 }
5564
5565 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566 return SWIG_Python_InitShadowInstance(args);
5567 }
5568
5569 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5570 PyObject *resultobj = 0;
5571 wxPoint *arg1 = (wxPoint *) 0 ;
5572 int arg2 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 int val2 ;
5576 int ecode2 = 0 ;
5577 PyObject *swig_obj[2] ;
5578
5579 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5581 if (!SWIG_IsOK(res1)) {
5582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5583 }
5584 arg1 = reinterpret_cast< wxPoint * >(argp1);
5585 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5586 if (!SWIG_IsOK(ecode2)) {
5587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5588 }
5589 arg2 = static_cast< int >(val2);
5590 if (arg1) (arg1)->x = arg2;
5591
5592 resultobj = SWIG_Py_Void();
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 PyObject *resultobj = 0;
5601 wxPoint *arg1 = (wxPoint *) 0 ;
5602 int result;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 PyObject *swig_obj[1] ;
5606
5607 if (!args) SWIG_fail;
5608 swig_obj[0] = args;
5609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5610 if (!SWIG_IsOK(res1)) {
5611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5612 }
5613 arg1 = reinterpret_cast< wxPoint * >(argp1);
5614 result = (int) ((arg1)->x);
5615 resultobj = SWIG_From_int(static_cast< int >(result));
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5623 PyObject *resultobj = 0;
5624 wxPoint *arg1 = (wxPoint *) 0 ;
5625 int arg2 ;
5626 void *argp1 = 0 ;
5627 int res1 = 0 ;
5628 int val2 ;
5629 int ecode2 = 0 ;
5630 PyObject *swig_obj[2] ;
5631
5632 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxPoint * >(argp1);
5638 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5639 if (!SWIG_IsOK(ecode2)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5641 }
5642 arg2 = static_cast< int >(val2);
5643 if (arg1) (arg1)->y = arg2;
5644
5645 resultobj = SWIG_Py_Void();
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5653 PyObject *resultobj = 0;
5654 wxPoint *arg1 = (wxPoint *) 0 ;
5655 int result;
5656 void *argp1 = 0 ;
5657 int res1 = 0 ;
5658 PyObject *swig_obj[1] ;
5659
5660 if (!args) SWIG_fail;
5661 swig_obj[0] = args;
5662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5663 if (!SWIG_IsOK(res1)) {
5664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5665 }
5666 arg1 = reinterpret_cast< wxPoint * >(argp1);
5667 result = (int) ((arg1)->y);
5668 resultobj = SWIG_From_int(static_cast< int >(result));
5669 return resultobj;
5670 fail:
5671 return NULL;
5672 }
5673
5674
5675 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5676 PyObject *resultobj = 0;
5677 int arg1 = (int) 0 ;
5678 int arg2 = (int) 0 ;
5679 wxPoint *result = 0 ;
5680 int val1 ;
5681 int ecode1 = 0 ;
5682 int val2 ;
5683 int ecode2 = 0 ;
5684 PyObject * obj0 = 0 ;
5685 PyObject * obj1 = 0 ;
5686 char * kwnames[] = {
5687 (char *) "x",(char *) "y", NULL
5688 };
5689
5690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5691 if (obj0) {
5692 ecode1 = SWIG_AsVal_int(obj0, &val1);
5693 if (!SWIG_IsOK(ecode1)) {
5694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5695 }
5696 arg1 = static_cast< int >(val1);
5697 }
5698 if (obj1) {
5699 ecode2 = SWIG_AsVal_int(obj1, &val2);
5700 if (!SWIG_IsOK(ecode2)) {
5701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5702 }
5703 arg2 = static_cast< int >(val2);
5704 }
5705 {
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 result = (wxPoint *)new wxPoint(arg1,arg2);
5708 wxPyEndAllowThreads(__tstate);
5709 if (PyErr_Occurred()) SWIG_fail;
5710 }
5711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5712 return resultobj;
5713 fail:
5714 return NULL;
5715 }
5716
5717
5718 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5719 PyObject *resultobj = 0;
5720 wxPoint *arg1 = (wxPoint *) 0 ;
5721 void *argp1 = 0 ;
5722 int res1 = 0 ;
5723 PyObject *swig_obj[1] ;
5724
5725 if (!args) SWIG_fail;
5726 swig_obj[0] = args;
5727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5728 if (!SWIG_IsOK(res1)) {
5729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5730 }
5731 arg1 = reinterpret_cast< wxPoint * >(argp1);
5732 {
5733 PyThreadState* __tstate = wxPyBeginAllowThreads();
5734 delete arg1;
5735
5736 wxPyEndAllowThreads(__tstate);
5737 if (PyErr_Occurred()) SWIG_fail;
5738 }
5739 resultobj = SWIG_Py_Void();
5740 return resultobj;
5741 fail:
5742 return NULL;
5743 }
5744
5745
5746 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5747 PyObject *resultobj = 0;
5748 wxPoint *arg1 = (wxPoint *) 0 ;
5749 PyObject *arg2 = (PyObject *) 0 ;
5750 bool result;
5751 void *argp1 = 0 ;
5752 int res1 = 0 ;
5753 PyObject * obj0 = 0 ;
5754 PyObject * obj1 = 0 ;
5755 char * kwnames[] = {
5756 (char *) "self",(char *) "other", NULL
5757 };
5758
5759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5761 if (!SWIG_IsOK(res1)) {
5762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5763 }
5764 arg1 = reinterpret_cast< wxPoint * >(argp1);
5765 arg2 = obj1;
5766 {
5767 result = (bool)wxPoint___eq__(arg1,arg2);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 {
5771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5772 }
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj = 0;
5781 wxPoint *arg1 = (wxPoint *) 0 ;
5782 PyObject *arg2 = (PyObject *) 0 ;
5783 bool result;
5784 void *argp1 = 0 ;
5785 int res1 = 0 ;
5786 PyObject * obj0 = 0 ;
5787 PyObject * obj1 = 0 ;
5788 char * kwnames[] = {
5789 (char *) "self",(char *) "other", NULL
5790 };
5791
5792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5796 }
5797 arg1 = reinterpret_cast< wxPoint * >(argp1);
5798 arg2 = obj1;
5799 {
5800 result = (bool)wxPoint___ne__(arg1,arg2);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 {
5804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5805 }
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5813 PyObject *resultobj = 0;
5814 wxPoint *arg1 = (wxPoint *) 0 ;
5815 wxPoint *arg2 = 0 ;
5816 wxPoint result;
5817 void *argp1 = 0 ;
5818 int res1 = 0 ;
5819 wxPoint temp2 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "pt", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 {
5833 arg2 = &temp2;
5834 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (arg1)->operator +((wxPoint const &)*arg2);
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 wxPoint *arg2 = 0 ;
5853 wxPoint result;
5854 void *argp1 = 0 ;
5855 int res1 = 0 ;
5856 wxPoint temp2 ;
5857 PyObject * obj0 = 0 ;
5858 PyObject * obj1 = 0 ;
5859 char * kwnames[] = {
5860 (char *) "self",(char *) "pt", NULL
5861 };
5862
5863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5865 if (!SWIG_IsOK(res1)) {
5866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5867 }
5868 arg1 = reinterpret_cast< wxPoint * >(argp1);
5869 {
5870 arg2 = &temp2;
5871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5872 }
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 result = (arg1)->operator -((wxPoint const &)*arg2);
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5887 PyObject *resultobj = 0;
5888 wxPoint *arg1 = (wxPoint *) 0 ;
5889 wxPoint *arg2 = 0 ;
5890 wxPoint *result = 0 ;
5891 void *argp1 = 0 ;
5892 int res1 = 0 ;
5893 wxPoint temp2 ;
5894 PyObject * obj0 = 0 ;
5895 PyObject * obj1 = 0 ;
5896 char * kwnames[] = {
5897 (char *) "self",(char *) "pt", NULL
5898 };
5899
5900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5902 if (!SWIG_IsOK(res1)) {
5903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5904 }
5905 arg1 = reinterpret_cast< wxPoint * >(argp1);
5906 {
5907 arg2 = &temp2;
5908 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5909 }
5910 {
5911 PyThreadState* __tstate = wxPyBeginAllowThreads();
5912 {
5913 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5914 result = (wxPoint *) &_result_ref;
5915 }
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj = 0;
5928 wxPoint *arg1 = (wxPoint *) 0 ;
5929 wxPoint *arg2 = 0 ;
5930 wxPoint *result = 0 ;
5931 void *argp1 = 0 ;
5932 int res1 = 0 ;
5933 wxPoint temp2 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 char * kwnames[] = {
5937 (char *) "self",(char *) "pt", NULL
5938 };
5939
5940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5942 if (!SWIG_IsOK(res1)) {
5943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5944 }
5945 arg1 = reinterpret_cast< wxPoint * >(argp1);
5946 {
5947 arg2 = &temp2;
5948 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5949 }
5950 {
5951 PyThreadState* __tstate = wxPyBeginAllowThreads();
5952 {
5953 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5954 result = (wxPoint *) &_result_ref;
5955 }
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = 0;
5968 wxPoint *arg1 = (wxPoint *) 0 ;
5969 long arg2 ;
5970 long arg3 ;
5971 void *argp1 = 0 ;
5972 int res1 = 0 ;
5973 long val2 ;
5974 int ecode2 = 0 ;
5975 long val3 ;
5976 int ecode3 = 0 ;
5977 PyObject * obj0 = 0 ;
5978 PyObject * obj1 = 0 ;
5979 PyObject * obj2 = 0 ;
5980 char * kwnames[] = {
5981 (char *) "self",(char *) "x",(char *) "y", NULL
5982 };
5983
5984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5986 if (!SWIG_IsOK(res1)) {
5987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5988 }
5989 arg1 = reinterpret_cast< wxPoint * >(argp1);
5990 ecode2 = SWIG_AsVal_long(obj1, &val2);
5991 if (!SWIG_IsOK(ecode2)) {
5992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5993 }
5994 arg2 = static_cast< long >(val2);
5995 ecode3 = SWIG_AsVal_long(obj2, &val3);
5996 if (!SWIG_IsOK(ecode3)) {
5997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5998 }
5999 arg3 = static_cast< long >(val3);
6000 {
6001 PyThreadState* __tstate = wxPyBeginAllowThreads();
6002 wxPoint_Set(arg1,arg2,arg3);
6003 wxPyEndAllowThreads(__tstate);
6004 if (PyErr_Occurred()) SWIG_fail;
6005 }
6006 resultobj = SWIG_Py_Void();
6007 return resultobj;
6008 fail:
6009 return NULL;
6010 }
6011
6012
6013 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6014 PyObject *resultobj = 0;
6015 wxPoint *arg1 = (wxPoint *) 0 ;
6016 PyObject *result = 0 ;
6017 void *argp1 = 0 ;
6018 int res1 = 0 ;
6019 PyObject *swig_obj[1] ;
6020
6021 if (!args) SWIG_fail;
6022 swig_obj[0] = args;
6023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6024 if (!SWIG_IsOK(res1)) {
6025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6026 }
6027 arg1 = reinterpret_cast< wxPoint * >(argp1);
6028 {
6029 PyThreadState* __tstate = wxPyBeginAllowThreads();
6030 result = (PyObject *)wxPoint_Get(arg1);
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 resultobj = result;
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6042 PyObject *obj;
6043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6044 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6045 return SWIG_Py_Void();
6046 }
6047
6048 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6049 return SWIG_Python_InitShadowInstance(args);
6050 }
6051
6052 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6053 PyObject *resultobj = 0;
6054 int arg1 = (int) 0 ;
6055 int arg2 = (int) 0 ;
6056 int arg3 = (int) 0 ;
6057 int arg4 = (int) 0 ;
6058 wxRect *result = 0 ;
6059 int val1 ;
6060 int ecode1 = 0 ;
6061 int val2 ;
6062 int ecode2 = 0 ;
6063 int val3 ;
6064 int ecode3 = 0 ;
6065 int val4 ;
6066 int ecode4 = 0 ;
6067 PyObject * obj0 = 0 ;
6068 PyObject * obj1 = 0 ;
6069 PyObject * obj2 = 0 ;
6070 PyObject * obj3 = 0 ;
6071 char * kwnames[] = {
6072 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6073 };
6074
6075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6076 if (obj0) {
6077 ecode1 = SWIG_AsVal_int(obj0, &val1);
6078 if (!SWIG_IsOK(ecode1)) {
6079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6080 }
6081 arg1 = static_cast< int >(val1);
6082 }
6083 if (obj1) {
6084 ecode2 = SWIG_AsVal_int(obj1, &val2);
6085 if (!SWIG_IsOK(ecode2)) {
6086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6087 }
6088 arg2 = static_cast< int >(val2);
6089 }
6090 if (obj2) {
6091 ecode3 = SWIG_AsVal_int(obj2, &val3);
6092 if (!SWIG_IsOK(ecode3)) {
6093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6094 }
6095 arg3 = static_cast< int >(val3);
6096 }
6097 if (obj3) {
6098 ecode4 = SWIG_AsVal_int(obj3, &val4);
6099 if (!SWIG_IsOK(ecode4)) {
6100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6101 }
6102 arg4 = static_cast< int >(val4);
6103 }
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6107 wxPyEndAllowThreads(__tstate);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6118 PyObject *resultobj = 0;
6119 wxPoint *arg1 = 0 ;
6120 wxPoint *arg2 = 0 ;
6121 wxRect *result = 0 ;
6122 wxPoint temp1 ;
6123 wxPoint temp2 ;
6124 PyObject * obj0 = 0 ;
6125 PyObject * obj1 = 0 ;
6126 char * kwnames[] = {
6127 (char *) "topLeft",(char *) "bottomRight", NULL
6128 };
6129
6130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6131 {
6132 arg1 = &temp1;
6133 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6134 }
6135 {
6136 arg2 = &temp2;
6137 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6146 return resultobj;
6147 fail:
6148 return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6153 PyObject *resultobj = 0;
6154 wxPoint *arg1 = 0 ;
6155 wxSize *arg2 = 0 ;
6156 wxRect *result = 0 ;
6157 wxPoint temp1 ;
6158 wxSize temp2 ;
6159 PyObject * obj0 = 0 ;
6160 PyObject * obj1 = 0 ;
6161 char * kwnames[] = {
6162 (char *) "pos",(char *) "size", NULL
6163 };
6164
6165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6166 {
6167 arg1 = &temp1;
6168 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6169 }
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize 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_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 wxSize *arg1 = 0 ;
6190 wxRect *result = 0 ;
6191 wxSize temp1 ;
6192 PyObject * obj0 = 0 ;
6193 char * kwnames[] = {
6194 (char *) "size", NULL
6195 };
6196
6197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6198 {
6199 arg1 = &temp1;
6200 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6201 }
6202 {
6203 PyThreadState* __tstate = wxPyBeginAllowThreads();
6204 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6205 wxPyEndAllowThreads(__tstate);
6206 if (PyErr_Occurred()) SWIG_fail;
6207 }
6208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6209 return resultobj;
6210 fail:
6211 return NULL;
6212 }
6213
6214
6215 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6216 PyObject *resultobj = 0;
6217 wxRect *arg1 = (wxRect *) 0 ;
6218 void *argp1 = 0 ;
6219 int res1 = 0 ;
6220 PyObject *swig_obj[1] ;
6221
6222 if (!args) SWIG_fail;
6223 swig_obj[0] = args;
6224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6225 if (!SWIG_IsOK(res1)) {
6226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6227 }
6228 arg1 = reinterpret_cast< wxRect * >(argp1);
6229 {
6230 PyThreadState* __tstate = wxPyBeginAllowThreads();
6231 delete arg1;
6232
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 resultobj = SWIG_Py_Void();
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6244 PyObject *resultobj = 0;
6245 wxRect *arg1 = (wxRect *) 0 ;
6246 int result;
6247 void *argp1 = 0 ;
6248 int res1 = 0 ;
6249 PyObject *swig_obj[1] ;
6250
6251 if (!args) SWIG_fail;
6252 swig_obj[0] = args;
6253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6254 if (!SWIG_IsOK(res1)) {
6255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6256 }
6257 arg1 = reinterpret_cast< wxRect * >(argp1);
6258 {
6259 PyThreadState* __tstate = wxPyBeginAllowThreads();
6260 result = (int)((wxRect const *)arg1)->GetX();
6261 wxPyEndAllowThreads(__tstate);
6262 if (PyErr_Occurred()) SWIG_fail;
6263 }
6264 resultobj = SWIG_From_int(static_cast< int >(result));
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj = 0;
6273 wxRect *arg1 = (wxRect *) 0 ;
6274 int arg2 ;
6275 void *argp1 = 0 ;
6276 int res1 = 0 ;
6277 int val2 ;
6278 int ecode2 = 0 ;
6279 PyObject * obj0 = 0 ;
6280 PyObject * obj1 = 0 ;
6281 char * kwnames[] = {
6282 (char *) "self",(char *) "x", NULL
6283 };
6284
6285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6287 if (!SWIG_IsOK(res1)) {
6288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6289 }
6290 arg1 = reinterpret_cast< wxRect * >(argp1);
6291 ecode2 = SWIG_AsVal_int(obj1, &val2);
6292 if (!SWIG_IsOK(ecode2)) {
6293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6294 }
6295 arg2 = static_cast< int >(val2);
6296 {
6297 PyThreadState* __tstate = wxPyBeginAllowThreads();
6298 (arg1)->SetX(arg2);
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 resultobj = SWIG_Py_Void();
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6310 PyObject *resultobj = 0;
6311 wxRect *arg1 = (wxRect *) 0 ;
6312 int result;
6313 void *argp1 = 0 ;
6314 int res1 = 0 ;
6315 PyObject *swig_obj[1] ;
6316
6317 if (!args) SWIG_fail;
6318 swig_obj[0] = args;
6319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6320 if (!SWIG_IsOK(res1)) {
6321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6322 }
6323 arg1 = reinterpret_cast< wxRect * >(argp1);
6324 {
6325 PyThreadState* __tstate = wxPyBeginAllowThreads();
6326 result = (int)(arg1)->GetY();
6327 wxPyEndAllowThreads(__tstate);
6328 if (PyErr_Occurred()) SWIG_fail;
6329 }
6330 resultobj = SWIG_From_int(static_cast< int >(result));
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj = 0;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int arg2 ;
6341 void *argp1 = 0 ;
6342 int res1 = 0 ;
6343 int val2 ;
6344 int ecode2 = 0 ;
6345 PyObject * obj0 = 0 ;
6346 PyObject * obj1 = 0 ;
6347 char * kwnames[] = {
6348 (char *) "self",(char *) "y", NULL
6349 };
6350
6351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6353 if (!SWIG_IsOK(res1)) {
6354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6355 }
6356 arg1 = reinterpret_cast< wxRect * >(argp1);
6357 ecode2 = SWIG_AsVal_int(obj1, &val2);
6358 if (!SWIG_IsOK(ecode2)) {
6359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6360 }
6361 arg2 = static_cast< int >(val2);
6362 {
6363 PyThreadState* __tstate = wxPyBeginAllowThreads();
6364 (arg1)->SetY(arg2);
6365 wxPyEndAllowThreads(__tstate);
6366 if (PyErr_Occurred()) SWIG_fail;
6367 }
6368 resultobj = SWIG_Py_Void();
6369 return resultobj;
6370 fail:
6371 return NULL;
6372 }
6373
6374
6375 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6376 PyObject *resultobj = 0;
6377 wxRect *arg1 = (wxRect *) 0 ;
6378 int result;
6379 void *argp1 = 0 ;
6380 int res1 = 0 ;
6381 PyObject *swig_obj[1] ;
6382
6383 if (!args) SWIG_fail;
6384 swig_obj[0] = args;
6385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6386 if (!SWIG_IsOK(res1)) {
6387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6388 }
6389 arg1 = reinterpret_cast< wxRect * >(argp1);
6390 {
6391 PyThreadState* __tstate = wxPyBeginAllowThreads();
6392 result = (int)((wxRect const *)arg1)->GetWidth();
6393 wxPyEndAllowThreads(__tstate);
6394 if (PyErr_Occurred()) SWIG_fail;
6395 }
6396 resultobj = SWIG_From_int(static_cast< int >(result));
6397 return resultobj;
6398 fail:
6399 return NULL;
6400 }
6401
6402
6403 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj = 0;
6405 wxRect *arg1 = (wxRect *) 0 ;
6406 int arg2 ;
6407 void *argp1 = 0 ;
6408 int res1 = 0 ;
6409 int val2 ;
6410 int ecode2 = 0 ;
6411 PyObject * obj0 = 0 ;
6412 PyObject * obj1 = 0 ;
6413 char * kwnames[] = {
6414 (char *) "self",(char *) "w", NULL
6415 };
6416
6417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6419 if (!SWIG_IsOK(res1)) {
6420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6421 }
6422 arg1 = reinterpret_cast< wxRect * >(argp1);
6423 ecode2 = SWIG_AsVal_int(obj1, &val2);
6424 if (!SWIG_IsOK(ecode2)) {
6425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6426 }
6427 arg2 = static_cast< int >(val2);
6428 {
6429 PyThreadState* __tstate = wxPyBeginAllowThreads();
6430 (arg1)->SetWidth(arg2);
6431 wxPyEndAllowThreads(__tstate);
6432 if (PyErr_Occurred()) SWIG_fail;
6433 }
6434 resultobj = SWIG_Py_Void();
6435 return resultobj;
6436 fail:
6437 return NULL;
6438 }
6439
6440
6441 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6442 PyObject *resultobj = 0;
6443 wxRect *arg1 = (wxRect *) 0 ;
6444 int result;
6445 void *argp1 = 0 ;
6446 int res1 = 0 ;
6447 PyObject *swig_obj[1] ;
6448
6449 if (!args) SWIG_fail;
6450 swig_obj[0] = args;
6451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6452 if (!SWIG_IsOK(res1)) {
6453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6454 }
6455 arg1 = reinterpret_cast< wxRect * >(argp1);
6456 {
6457 PyThreadState* __tstate = wxPyBeginAllowThreads();
6458 result = (int)((wxRect const *)arg1)->GetHeight();
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = SWIG_From_int(static_cast< int >(result));
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6470 PyObject *resultobj = 0;
6471 wxRect *arg1 = (wxRect *) 0 ;
6472 int arg2 ;
6473 void *argp1 = 0 ;
6474 int res1 = 0 ;
6475 int val2 ;
6476 int ecode2 = 0 ;
6477 PyObject * obj0 = 0 ;
6478 PyObject * obj1 = 0 ;
6479 char * kwnames[] = {
6480 (char *) "self",(char *) "h", NULL
6481 };
6482
6483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6485 if (!SWIG_IsOK(res1)) {
6486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6487 }
6488 arg1 = reinterpret_cast< wxRect * >(argp1);
6489 ecode2 = SWIG_AsVal_int(obj1, &val2);
6490 if (!SWIG_IsOK(ecode2)) {
6491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6492 }
6493 arg2 = static_cast< int >(val2);
6494 {
6495 PyThreadState* __tstate = wxPyBeginAllowThreads();
6496 (arg1)->SetHeight(arg2);
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = SWIG_Py_Void();
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6508 PyObject *resultobj = 0;
6509 wxRect *arg1 = (wxRect *) 0 ;
6510 wxPoint result;
6511 void *argp1 = 0 ;
6512 int res1 = 0 ;
6513 PyObject *swig_obj[1] ;
6514
6515 if (!args) SWIG_fail;
6516 swig_obj[0] = args;
6517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6518 if (!SWIG_IsOK(res1)) {
6519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6520 }
6521 arg1 = reinterpret_cast< wxRect * >(argp1);
6522 {
6523 PyThreadState* __tstate = wxPyBeginAllowThreads();
6524 result = ((wxRect const *)arg1)->GetPosition();
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj = 0;
6537 wxRect *arg1 = (wxRect *) 0 ;
6538 wxPoint *arg2 = 0 ;
6539 void *argp1 = 0 ;
6540 int res1 = 0 ;
6541 wxPoint temp2 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "p", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 {
6555 arg2 = &temp2;
6556 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6557 }
6558 {
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 (arg1)->SetPosition((wxPoint const &)*arg2);
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 resultobj = SWIG_Py_Void();
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6572 PyObject *resultobj = 0;
6573 wxRect *arg1 = (wxRect *) 0 ;
6574 wxSize result;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 PyObject *swig_obj[1] ;
6578
6579 if (!args) SWIG_fail;
6580 swig_obj[0] = args;
6581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6582 if (!SWIG_IsOK(res1)) {
6583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6584 }
6585 arg1 = reinterpret_cast< wxRect * >(argp1);
6586 {
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 result = ((wxRect const *)arg1)->GetSize();
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 wxSize *arg2 = 0 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 wxSize temp2 ;
6606 PyObject * obj0 = 0 ;
6607 PyObject * obj1 = 0 ;
6608 char * kwnames[] = {
6609 (char *) "self",(char *) "s", NULL
6610 };
6611
6612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6614 if (!SWIG_IsOK(res1)) {
6615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6616 }
6617 arg1 = reinterpret_cast< wxRect * >(argp1);
6618 {
6619 arg2 = &temp2;
6620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6621 }
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 (arg1)->SetSize((wxSize const &)*arg2);
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_Py_Void();
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 bool result;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 PyObject *swig_obj[1] ;
6642
6643 if (!args) SWIG_fail;
6644 swig_obj[0] = args;
6645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6646 if (!SWIG_IsOK(res1)) {
6647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6648 }
6649 arg1 = reinterpret_cast< wxRect * >(argp1);
6650 {
6651 PyThreadState* __tstate = wxPyBeginAllowThreads();
6652 result = (bool)((wxRect const *)arg1)->IsEmpty();
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 {
6657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6658 }
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6666 PyObject *resultobj = 0;
6667 wxRect *arg1 = (wxRect *) 0 ;
6668 wxPoint result;
6669 void *argp1 = 0 ;
6670 int res1 = 0 ;
6671 PyObject *swig_obj[1] ;
6672
6673 if (!args) SWIG_fail;
6674 swig_obj[0] = args;
6675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6676 if (!SWIG_IsOK(res1)) {
6677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6678 }
6679 arg1 = reinterpret_cast< wxRect * >(argp1);
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 result = ((wxRect const *)arg1)->GetTopLeft();
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6687 return resultobj;
6688 fail:
6689 return NULL;
6690 }
6691
6692
6693 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6694 PyObject *resultobj = 0;
6695 wxRect *arg1 = (wxRect *) 0 ;
6696 wxPoint *arg2 = 0 ;
6697 void *argp1 = 0 ;
6698 int res1 = 0 ;
6699 wxPoint temp2 ;
6700 PyObject * obj0 = 0 ;
6701 PyObject * obj1 = 0 ;
6702 char * kwnames[] = {
6703 (char *) "self",(char *) "p", NULL
6704 };
6705
6706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6708 if (!SWIG_IsOK(res1)) {
6709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6710 }
6711 arg1 = reinterpret_cast< wxRect * >(argp1);
6712 {
6713 arg2 = &temp2;
6714 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6715 }
6716 {
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 resultobj = SWIG_Py_Void();
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730 PyObject *resultobj = 0;
6731 wxRect *arg1 = (wxRect *) 0 ;
6732 wxPoint result;
6733 void *argp1 = 0 ;
6734 int res1 = 0 ;
6735 PyObject *swig_obj[1] ;
6736
6737 if (!args) SWIG_fail;
6738 swig_obj[0] = args;
6739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6740 if (!SWIG_IsOK(res1)) {
6741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6742 }
6743 arg1 = reinterpret_cast< wxRect * >(argp1);
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 result = ((wxRect const *)arg1)->GetBottomRight();
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6758 PyObject *resultobj = 0;
6759 wxRect *arg1 = (wxRect *) 0 ;
6760 wxPoint *arg2 = 0 ;
6761 void *argp1 = 0 ;
6762 int res1 = 0 ;
6763 wxPoint temp2 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 char * kwnames[] = {
6767 (char *) "self",(char *) "p", NULL
6768 };
6769
6770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6772 if (!SWIG_IsOK(res1)) {
6773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6774 }
6775 arg1 = reinterpret_cast< wxRect * >(argp1);
6776 {
6777 arg2 = &temp2;
6778 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6779 }
6780 {
6781 PyThreadState* __tstate = wxPyBeginAllowThreads();
6782 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_Py_Void();
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 wxRect *arg1 = (wxRect *) 0 ;
6796 int result;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 PyObject *swig_obj[1] ;
6800
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6806 }
6807 arg1 = reinterpret_cast< wxRect * >(argp1);
6808 {
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (int)((wxRect const *)arg1)->GetLeft();
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_From_int(static_cast< int >(result));
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6822 PyObject *resultobj = 0;
6823 wxRect *arg1 = (wxRect *) 0 ;
6824 int result;
6825 void *argp1 = 0 ;
6826 int res1 = 0 ;
6827 PyObject *swig_obj[1] ;
6828
6829 if (!args) SWIG_fail;
6830 swig_obj[0] = args;
6831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6832 if (!SWIG_IsOK(res1)) {
6833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6834 }
6835 arg1 = reinterpret_cast< wxRect * >(argp1);
6836 {
6837 PyThreadState* __tstate = wxPyBeginAllowThreads();
6838 result = (int)((wxRect const *)arg1)->GetTop();
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 resultobj = SWIG_From_int(static_cast< int >(result));
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6850 PyObject *resultobj = 0;
6851 wxRect *arg1 = (wxRect *) 0 ;
6852 int result;
6853 void *argp1 = 0 ;
6854 int res1 = 0 ;
6855 PyObject *swig_obj[1] ;
6856
6857 if (!args) SWIG_fail;
6858 swig_obj[0] = args;
6859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6860 if (!SWIG_IsOK(res1)) {
6861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6862 }
6863 arg1 = reinterpret_cast< wxRect * >(argp1);
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 result = (int)((wxRect const *)arg1)->GetBottom();
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 resultobj = SWIG_From_int(static_cast< int >(result));
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6878 PyObject *resultobj = 0;
6879 wxRect *arg1 = (wxRect *) 0 ;
6880 int result;
6881 void *argp1 = 0 ;
6882 int res1 = 0 ;
6883 PyObject *swig_obj[1] ;
6884
6885 if (!args) SWIG_fail;
6886 swig_obj[0] = args;
6887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6888 if (!SWIG_IsOK(res1)) {
6889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6890 }
6891 arg1 = reinterpret_cast< wxRect * >(argp1);
6892 {
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 result = (int)((wxRect const *)arg1)->GetRight();
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 resultobj = SWIG_From_int(static_cast< int >(result));
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6906 PyObject *resultobj = 0;
6907 wxRect *arg1 = (wxRect *) 0 ;
6908 int arg2 ;
6909 void *argp1 = 0 ;
6910 int res1 = 0 ;
6911 int val2 ;
6912 int ecode2 = 0 ;
6913 PyObject * obj0 = 0 ;
6914 PyObject * obj1 = 0 ;
6915 char * kwnames[] = {
6916 (char *) "self",(char *) "left", NULL
6917 };
6918
6919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6921 if (!SWIG_IsOK(res1)) {
6922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6923 }
6924 arg1 = reinterpret_cast< wxRect * >(argp1);
6925 ecode2 = SWIG_AsVal_int(obj1, &val2);
6926 if (!SWIG_IsOK(ecode2)) {
6927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6928 }
6929 arg2 = static_cast< int >(val2);
6930 {
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 (arg1)->SetLeft(arg2);
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_Py_Void();
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj = 0;
6945 wxRect *arg1 = (wxRect *) 0 ;
6946 int arg2 ;
6947 void *argp1 = 0 ;
6948 int res1 = 0 ;
6949 int val2 ;
6950 int ecode2 = 0 ;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 char * kwnames[] = {
6954 (char *) "self",(char *) "right", NULL
6955 };
6956
6957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6959 if (!SWIG_IsOK(res1)) {
6960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6961 }
6962 arg1 = reinterpret_cast< wxRect * >(argp1);
6963 ecode2 = SWIG_AsVal_int(obj1, &val2);
6964 if (!SWIG_IsOK(ecode2)) {
6965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6966 }
6967 arg2 = static_cast< int >(val2);
6968 {
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 (arg1)->SetRight(arg2);
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 resultobj = SWIG_Py_Void();
6975 return resultobj;
6976 fail:
6977 return NULL;
6978 }
6979
6980
6981 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6982 PyObject *resultobj = 0;
6983 wxRect *arg1 = (wxRect *) 0 ;
6984 int arg2 ;
6985 void *argp1 = 0 ;
6986 int res1 = 0 ;
6987 int val2 ;
6988 int ecode2 = 0 ;
6989 PyObject * obj0 = 0 ;
6990 PyObject * obj1 = 0 ;
6991 char * kwnames[] = {
6992 (char *) "self",(char *) "top", NULL
6993 };
6994
6995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6997 if (!SWIG_IsOK(res1)) {
6998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6999 }
7000 arg1 = reinterpret_cast< wxRect * >(argp1);
7001 ecode2 = SWIG_AsVal_int(obj1, &val2);
7002 if (!SWIG_IsOK(ecode2)) {
7003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7004 }
7005 arg2 = static_cast< int >(val2);
7006 {
7007 PyThreadState* __tstate = wxPyBeginAllowThreads();
7008 (arg1)->SetTop(arg2);
7009 wxPyEndAllowThreads(__tstate);
7010 if (PyErr_Occurred()) SWIG_fail;
7011 }
7012 resultobj = SWIG_Py_Void();
7013 return resultobj;
7014 fail:
7015 return NULL;
7016 }
7017
7018
7019 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7020 PyObject *resultobj = 0;
7021 wxRect *arg1 = (wxRect *) 0 ;
7022 int arg2 ;
7023 void *argp1 = 0 ;
7024 int res1 = 0 ;
7025 int val2 ;
7026 int ecode2 = 0 ;
7027 PyObject * obj0 = 0 ;
7028 PyObject * obj1 = 0 ;
7029 char * kwnames[] = {
7030 (char *) "self",(char *) "bottom", NULL
7031 };
7032
7033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 ecode2 = SWIG_AsVal_int(obj1, &val2);
7040 if (!SWIG_IsOK(ecode2)) {
7041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7042 }
7043 arg2 = static_cast< int >(val2);
7044 {
7045 PyThreadState* __tstate = wxPyBeginAllowThreads();
7046 (arg1)->SetBottom(arg2);
7047 wxPyEndAllowThreads(__tstate);
7048 if (PyErr_Occurred()) SWIG_fail;
7049 }
7050 resultobj = SWIG_Py_Void();
7051 return resultobj;
7052 fail:
7053 return NULL;
7054 }
7055
7056
7057 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7058 PyObject *resultobj = 0;
7059 wxRect *arg1 = (wxRect *) 0 ;
7060 int arg2 ;
7061 int arg3 ;
7062 wxRect *result = 0 ;
7063 void *argp1 = 0 ;
7064 int res1 = 0 ;
7065 int val2 ;
7066 int ecode2 = 0 ;
7067 int val3 ;
7068 int ecode3 = 0 ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 PyObject * obj2 = 0 ;
7072 char * kwnames[] = {
7073 (char *) "self",(char *) "dx",(char *) "dy", NULL
7074 };
7075
7076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7078 if (!SWIG_IsOK(res1)) {
7079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7080 }
7081 arg1 = reinterpret_cast< wxRect * >(argp1);
7082 ecode2 = SWIG_AsVal_int(obj1, &val2);
7083 if (!SWIG_IsOK(ecode2)) {
7084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7085 }
7086 arg2 = static_cast< int >(val2);
7087 ecode3 = SWIG_AsVal_int(obj2, &val3);
7088 if (!SWIG_IsOK(ecode3)) {
7089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7090 }
7091 arg3 = static_cast< int >(val3);
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 {
7095 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7096 result = (wxRect *) &_result_ref;
7097 }
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 int arg2 ;
7112 int arg3 ;
7113 wxRect *result = 0 ;
7114 void *argp1 = 0 ;
7115 int res1 = 0 ;
7116 int val2 ;
7117 int ecode2 = 0 ;
7118 int val3 ;
7119 int ecode3 = 0 ;
7120 PyObject * obj0 = 0 ;
7121 PyObject * obj1 = 0 ;
7122 PyObject * obj2 = 0 ;
7123 char * kwnames[] = {
7124 (char *) "self",(char *) "dx",(char *) "dy", NULL
7125 };
7126
7127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7129 if (!SWIG_IsOK(res1)) {
7130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7131 }
7132 arg1 = reinterpret_cast< wxRect * >(argp1);
7133 ecode2 = SWIG_AsVal_int(obj1, &val2);
7134 if (!SWIG_IsOK(ecode2)) {
7135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7136 }
7137 arg2 = static_cast< int >(val2);
7138 ecode3 = SWIG_AsVal_int(obj2, &val3);
7139 if (!SWIG_IsOK(ecode3)) {
7140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7141 }
7142 arg3 = static_cast< int >(val3);
7143 {
7144 PyThreadState* __tstate = wxPyBeginAllowThreads();
7145 {
7146 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7147 result = (wxRect *) &_result_ref;
7148 }
7149 wxPyEndAllowThreads(__tstate);
7150 if (PyErr_Occurred()) SWIG_fail;
7151 }
7152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7153 return resultobj;
7154 fail:
7155 return NULL;
7156 }
7157
7158
7159 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7160 PyObject *resultobj = 0;
7161 wxRect *arg1 = (wxRect *) 0 ;
7162 int arg2 ;
7163 int arg3 ;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 int val2 ;
7167 int ecode2 = 0 ;
7168 int val3 ;
7169 int ecode3 = 0 ;
7170 PyObject * obj0 = 0 ;
7171 PyObject * obj1 = 0 ;
7172 PyObject * obj2 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "dx",(char *) "dy", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 ecode2 = SWIG_AsVal_int(obj1, &val2);
7184 if (!SWIG_IsOK(ecode2)) {
7185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7186 }
7187 arg2 = static_cast< int >(val2);
7188 ecode3 = SWIG_AsVal_int(obj2, &val3);
7189 if (!SWIG_IsOK(ecode3)) {
7190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7191 }
7192 arg3 = static_cast< int >(val3);
7193 {
7194 PyThreadState* __tstate = wxPyBeginAllowThreads();
7195 (arg1)->Offset(arg2,arg3);
7196 wxPyEndAllowThreads(__tstate);
7197 if (PyErr_Occurred()) SWIG_fail;
7198 }
7199 resultobj = SWIG_Py_Void();
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj = 0;
7208 wxRect *arg1 = (wxRect *) 0 ;
7209 wxPoint *arg2 = 0 ;
7210 void *argp1 = 0 ;
7211 int res1 = 0 ;
7212 wxPoint temp2 ;
7213 PyObject * obj0 = 0 ;
7214 PyObject * obj1 = 0 ;
7215 char * kwnames[] = {
7216 (char *) "self",(char *) "pt", NULL
7217 };
7218
7219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7221 if (!SWIG_IsOK(res1)) {
7222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7223 }
7224 arg1 = reinterpret_cast< wxRect * >(argp1);
7225 {
7226 arg2 = &temp2;
7227 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7228 }
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 (arg1)->Offset((wxPoint const &)*arg2);
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_Py_Void();
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = 0;
7244 wxRect *arg1 = (wxRect *) 0 ;
7245 wxRect *arg2 = 0 ;
7246 wxRect result;
7247 void *argp1 = 0 ;
7248 int res1 = 0 ;
7249 wxRect temp2 ;
7250 PyObject * obj0 = 0 ;
7251 PyObject * obj1 = 0 ;
7252 char * kwnames[] = {
7253 (char *) "self",(char *) "rect", NULL
7254 };
7255
7256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7258 if (!SWIG_IsOK(res1)) {
7259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7260 }
7261 arg1 = reinterpret_cast< wxRect * >(argp1);
7262 {
7263 arg2 = &temp2;
7264 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7265 }
7266 {
7267 PyThreadState* __tstate = wxPyBeginAllowThreads();
7268 result = (arg1)->Intersect((wxRect const &)*arg2);
7269 wxPyEndAllowThreads(__tstate);
7270 if (PyErr_Occurred()) SWIG_fail;
7271 }
7272 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj = 0;
7281 wxRect *arg1 = (wxRect *) 0 ;
7282 wxRect *arg2 = 0 ;
7283 wxRect result;
7284 void *argp1 = 0 ;
7285 int res1 = 0 ;
7286 wxRect temp2 ;
7287 PyObject * obj0 = 0 ;
7288 PyObject * obj1 = 0 ;
7289 char * kwnames[] = {
7290 (char *) "self",(char *) "rect", NULL
7291 };
7292
7293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7295 if (!SWIG_IsOK(res1)) {
7296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7297 }
7298 arg1 = reinterpret_cast< wxRect * >(argp1);
7299 {
7300 arg2 = &temp2;
7301 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 result = (arg1)->Union((wxRect const &)*arg2);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 wxRect *arg2 = 0 ;
7320 wxRect result;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 wxRect temp2 ;
7324 PyObject * obj0 = 0 ;
7325 PyObject * obj1 = 0 ;
7326 char * kwnames[] = {
7327 (char *) "self",(char *) "rect", NULL
7328 };
7329
7330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7334 }
7335 arg1 = reinterpret_cast< wxRect * >(argp1);
7336 {
7337 arg2 = &temp2;
7338 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7339 }
7340 {
7341 PyThreadState* __tstate = wxPyBeginAllowThreads();
7342 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7343 wxPyEndAllowThreads(__tstate);
7344 if (PyErr_Occurred()) SWIG_fail;
7345 }
7346 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7347 return resultobj;
7348 fail:
7349 return NULL;
7350 }
7351
7352
7353 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj = 0;
7355 wxRect *arg1 = (wxRect *) 0 ;
7356 wxRect *arg2 = 0 ;
7357 wxRect *result = 0 ;
7358 void *argp1 = 0 ;
7359 int res1 = 0 ;
7360 wxRect temp2 ;
7361 PyObject * obj0 = 0 ;
7362 PyObject * obj1 = 0 ;
7363 char * kwnames[] = {
7364 (char *) "self",(char *) "rect", NULL
7365 };
7366
7367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7369 if (!SWIG_IsOK(res1)) {
7370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7371 }
7372 arg1 = reinterpret_cast< wxRect * >(argp1);
7373 {
7374 arg2 = &temp2;
7375 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7376 }
7377 {
7378 PyThreadState* __tstate = wxPyBeginAllowThreads();
7379 {
7380 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7381 result = (wxRect *) &_result_ref;
7382 }
7383 wxPyEndAllowThreads(__tstate);
7384 if (PyErr_Occurred()) SWIG_fail;
7385 }
7386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj = 0;
7395 wxRect *arg1 = (wxRect *) 0 ;
7396 PyObject *arg2 = (PyObject *) 0 ;
7397 bool result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject * obj0 = 0 ;
7401 PyObject * obj1 = 0 ;
7402 char * kwnames[] = {
7403 (char *) "self",(char *) "other", NULL
7404 };
7405
7406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7408 if (!SWIG_IsOK(res1)) {
7409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7410 }
7411 arg1 = reinterpret_cast< wxRect * >(argp1);
7412 arg2 = obj1;
7413 {
7414 result = (bool)wxRect___eq__(arg1,arg2);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 PyObject *arg2 = (PyObject *) 0 ;
7430 bool result;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 PyObject * obj0 = 0 ;
7434 PyObject * obj1 = 0 ;
7435 char * kwnames[] = {
7436 (char *) "self",(char *) "other", NULL
7437 };
7438
7439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7441 if (!SWIG_IsOK(res1)) {
7442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7443 }
7444 arg1 = reinterpret_cast< wxRect * >(argp1);
7445 arg2 = obj1;
7446 {
7447 result = (bool)wxRect___ne__(arg1,arg2);
7448 if (PyErr_Occurred()) SWIG_fail;
7449 }
7450 {
7451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7452 }
7453 return resultobj;
7454 fail:
7455 return NULL;
7456 }
7457
7458
7459 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7460 PyObject *resultobj = 0;
7461 wxRect *arg1 = (wxRect *) 0 ;
7462 int arg2 ;
7463 int arg3 ;
7464 bool result;
7465 void *argp1 = 0 ;
7466 int res1 = 0 ;
7467 int val2 ;
7468 int ecode2 = 0 ;
7469 int val3 ;
7470 int ecode3 = 0 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 PyObject * obj2 = 0 ;
7474 char * kwnames[] = {
7475 (char *) "self",(char *) "x",(char *) "y", NULL
7476 };
7477
7478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7480 if (!SWIG_IsOK(res1)) {
7481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7482 }
7483 arg1 = reinterpret_cast< wxRect * >(argp1);
7484 ecode2 = SWIG_AsVal_int(obj1, &val2);
7485 if (!SWIG_IsOK(ecode2)) {
7486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7487 }
7488 arg2 = static_cast< int >(val2);
7489 ecode3 = SWIG_AsVal_int(obj2, &val3);
7490 if (!SWIG_IsOK(ecode3)) {
7491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7492 }
7493 arg3 = static_cast< int >(val3);
7494 {
7495 PyThreadState* __tstate = wxPyBeginAllowThreads();
7496 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7497 wxPyEndAllowThreads(__tstate);
7498 if (PyErr_Occurred()) SWIG_fail;
7499 }
7500 {
7501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7502 }
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj = 0;
7511 wxRect *arg1 = (wxRect *) 0 ;
7512 wxPoint *arg2 = 0 ;
7513 bool result;
7514 void *argp1 = 0 ;
7515 int res1 = 0 ;
7516 wxPoint temp2 ;
7517 PyObject * obj0 = 0 ;
7518 PyObject * obj1 = 0 ;
7519 char * kwnames[] = {
7520 (char *) "self",(char *) "pt", NULL
7521 };
7522
7523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7527 }
7528 arg1 = reinterpret_cast< wxRect * >(argp1);
7529 {
7530 arg2 = &temp2;
7531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7532 }
7533 {
7534 PyThreadState* __tstate = wxPyBeginAllowThreads();
7535 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7536 wxPyEndAllowThreads(__tstate);
7537 if (PyErr_Occurred()) SWIG_fail;
7538 }
7539 {
7540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7541 }
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7549 PyObject *resultobj = 0;
7550 wxRect *arg1 = (wxRect *) 0 ;
7551 wxRect *arg2 = 0 ;
7552 bool result;
7553 void *argp1 = 0 ;
7554 int res1 = 0 ;
7555 wxRect temp2 ;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 char * kwnames[] = {
7559 (char *) "self",(char *) "rect", NULL
7560 };
7561
7562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7564 if (!SWIG_IsOK(res1)) {
7565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7566 }
7567 arg1 = reinterpret_cast< wxRect * >(argp1);
7568 {
7569 arg2 = &temp2;
7570 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7571 }
7572 {
7573 PyThreadState* __tstate = wxPyBeginAllowThreads();
7574 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 {
7579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7580 }
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj = 0;
7589 wxRect *arg1 = (wxRect *) 0 ;
7590 wxRect *arg2 = 0 ;
7591 int arg3 = (int) wxBOTH ;
7592 wxRect result;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 wxRect temp2 ;
7596 int val3 ;
7597 int ecode3 = 0 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 PyObject * obj2 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "r",(char *) "dir", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 {
7612 arg2 = &temp2;
7613 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7614 }
7615 if (obj2) {
7616 ecode3 = SWIG_AsVal_int(obj2, &val3);
7617 if (!SWIG_IsOK(ecode3)) {
7618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7619 }
7620 arg3 = static_cast< int >(val3);
7621 }
7622 {
7623 PyThreadState* __tstate = wxPyBeginAllowThreads();
7624 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7625 wxPyEndAllowThreads(__tstate);
7626 if (PyErr_Occurred()) SWIG_fail;
7627 }
7628 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7629 return resultobj;
7630 fail:
7631 return NULL;
7632 }
7633
7634
7635 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7636 PyObject *resultobj = 0;
7637 wxRect *arg1 = (wxRect *) 0 ;
7638 int arg2 ;
7639 void *argp1 = 0 ;
7640 int res1 = 0 ;
7641 int val2 ;
7642 int ecode2 = 0 ;
7643 PyObject *swig_obj[2] ;
7644
7645 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7647 if (!SWIG_IsOK(res1)) {
7648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7649 }
7650 arg1 = reinterpret_cast< wxRect * >(argp1);
7651 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7652 if (!SWIG_IsOK(ecode2)) {
7653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7654 }
7655 arg2 = static_cast< int >(val2);
7656 if (arg1) (arg1)->x = arg2;
7657
7658 resultobj = SWIG_Py_Void();
7659 return resultobj;
7660 fail:
7661 return NULL;
7662 }
7663
7664
7665 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7666 PyObject *resultobj = 0;
7667 wxRect *arg1 = (wxRect *) 0 ;
7668 int result;
7669 void *argp1 = 0 ;
7670 int res1 = 0 ;
7671 PyObject *swig_obj[1] ;
7672
7673 if (!args) SWIG_fail;
7674 swig_obj[0] = args;
7675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7676 if (!SWIG_IsOK(res1)) {
7677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7678 }
7679 arg1 = reinterpret_cast< wxRect * >(argp1);
7680 result = (int) ((arg1)->x);
7681 resultobj = SWIG_From_int(static_cast< int >(result));
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7689 PyObject *resultobj = 0;
7690 wxRect *arg1 = (wxRect *) 0 ;
7691 int arg2 ;
7692 void *argp1 = 0 ;
7693 int res1 = 0 ;
7694 int val2 ;
7695 int ecode2 = 0 ;
7696 PyObject *swig_obj[2] ;
7697
7698 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7700 if (!SWIG_IsOK(res1)) {
7701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7702 }
7703 arg1 = reinterpret_cast< wxRect * >(argp1);
7704 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7705 if (!SWIG_IsOK(ecode2)) {
7706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7707 }
7708 arg2 = static_cast< int >(val2);
7709 if (arg1) (arg1)->y = arg2;
7710
7711 resultobj = SWIG_Py_Void();
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7719 PyObject *resultobj = 0;
7720 wxRect *arg1 = (wxRect *) 0 ;
7721 int result;
7722 void *argp1 = 0 ;
7723 int res1 = 0 ;
7724 PyObject *swig_obj[1] ;
7725
7726 if (!args) SWIG_fail;
7727 swig_obj[0] = args;
7728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7729 if (!SWIG_IsOK(res1)) {
7730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7731 }
7732 arg1 = reinterpret_cast< wxRect * >(argp1);
7733 result = (int) ((arg1)->y);
7734 resultobj = SWIG_From_int(static_cast< int >(result));
7735 return resultobj;
7736 fail:
7737 return NULL;
7738 }
7739
7740
7741 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7742 PyObject *resultobj = 0;
7743 wxRect *arg1 = (wxRect *) 0 ;
7744 int arg2 ;
7745 void *argp1 = 0 ;
7746 int res1 = 0 ;
7747 int val2 ;
7748 int ecode2 = 0 ;
7749 PyObject *swig_obj[2] ;
7750
7751 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7753 if (!SWIG_IsOK(res1)) {
7754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7755 }
7756 arg1 = reinterpret_cast< wxRect * >(argp1);
7757 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7758 if (!SWIG_IsOK(ecode2)) {
7759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7760 }
7761 arg2 = static_cast< int >(val2);
7762 if (arg1) (arg1)->width = arg2;
7763
7764 resultobj = SWIG_Py_Void();
7765 return resultobj;
7766 fail:
7767 return NULL;
7768 }
7769
7770
7771 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7772 PyObject *resultobj = 0;
7773 wxRect *arg1 = (wxRect *) 0 ;
7774 int result;
7775 void *argp1 = 0 ;
7776 int res1 = 0 ;
7777 PyObject *swig_obj[1] ;
7778
7779 if (!args) SWIG_fail;
7780 swig_obj[0] = args;
7781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7782 if (!SWIG_IsOK(res1)) {
7783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7784 }
7785 arg1 = reinterpret_cast< wxRect * >(argp1);
7786 result = (int) ((arg1)->width);
7787 resultobj = SWIG_From_int(static_cast< int >(result));
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
7794 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7795 PyObject *resultobj = 0;
7796 wxRect *arg1 = (wxRect *) 0 ;
7797 int arg2 ;
7798 void *argp1 = 0 ;
7799 int res1 = 0 ;
7800 int val2 ;
7801 int ecode2 = 0 ;
7802 PyObject *swig_obj[2] ;
7803
7804 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7806 if (!SWIG_IsOK(res1)) {
7807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7808 }
7809 arg1 = reinterpret_cast< wxRect * >(argp1);
7810 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7811 if (!SWIG_IsOK(ecode2)) {
7812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7813 }
7814 arg2 = static_cast< int >(val2);
7815 if (arg1) (arg1)->height = arg2;
7816
7817 resultobj = SWIG_Py_Void();
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7825 PyObject *resultobj = 0;
7826 wxRect *arg1 = (wxRect *) 0 ;
7827 int result;
7828 void *argp1 = 0 ;
7829 int res1 = 0 ;
7830 PyObject *swig_obj[1] ;
7831
7832 if (!args) SWIG_fail;
7833 swig_obj[0] = args;
7834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7835 if (!SWIG_IsOK(res1)) {
7836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7837 }
7838 arg1 = reinterpret_cast< wxRect * >(argp1);
7839 result = (int) ((arg1)->height);
7840 resultobj = SWIG_From_int(static_cast< int >(result));
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7848 PyObject *resultobj = 0;
7849 wxRect *arg1 = (wxRect *) 0 ;
7850 int arg2 = (int) 0 ;
7851 int arg3 = (int) 0 ;
7852 int arg4 = (int) 0 ;
7853 int arg5 = (int) 0 ;
7854 void *argp1 = 0 ;
7855 int res1 = 0 ;
7856 int val2 ;
7857 int ecode2 = 0 ;
7858 int val3 ;
7859 int ecode3 = 0 ;
7860 int val4 ;
7861 int ecode4 = 0 ;
7862 int val5 ;
7863 int ecode5 = 0 ;
7864 PyObject * obj0 = 0 ;
7865 PyObject * obj1 = 0 ;
7866 PyObject * obj2 = 0 ;
7867 PyObject * obj3 = 0 ;
7868 PyObject * obj4 = 0 ;
7869 char * kwnames[] = {
7870 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7871 };
7872
7873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7875 if (!SWIG_IsOK(res1)) {
7876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7877 }
7878 arg1 = reinterpret_cast< wxRect * >(argp1);
7879 if (obj1) {
7880 ecode2 = SWIG_AsVal_int(obj1, &val2);
7881 if (!SWIG_IsOK(ecode2)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7883 }
7884 arg2 = static_cast< int >(val2);
7885 }
7886 if (obj2) {
7887 ecode3 = SWIG_AsVal_int(obj2, &val3);
7888 if (!SWIG_IsOK(ecode3)) {
7889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7890 }
7891 arg3 = static_cast< int >(val3);
7892 }
7893 if (obj3) {
7894 ecode4 = SWIG_AsVal_int(obj3, &val4);
7895 if (!SWIG_IsOK(ecode4)) {
7896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7897 }
7898 arg4 = static_cast< int >(val4);
7899 }
7900 if (obj4) {
7901 ecode5 = SWIG_AsVal_int(obj4, &val5);
7902 if (!SWIG_IsOK(ecode5)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7904 }
7905 arg5 = static_cast< int >(val5);
7906 }
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_Py_Void();
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7921 PyObject *resultobj = 0;
7922 wxRect *arg1 = (wxRect *) 0 ;
7923 PyObject *result = 0 ;
7924 void *argp1 = 0 ;
7925 int res1 = 0 ;
7926 PyObject *swig_obj[1] ;
7927
7928 if (!args) SWIG_fail;
7929 swig_obj[0] = args;
7930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7931 if (!SWIG_IsOK(res1)) {
7932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7933 }
7934 arg1 = reinterpret_cast< wxRect * >(argp1);
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (PyObject *)wxRect_Get(arg1);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = result;
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7949 PyObject *obj;
7950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7951 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7952 return SWIG_Py_Void();
7953 }
7954
7955 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7956 return SWIG_Python_InitShadowInstance(args);
7957 }
7958
7959 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7960 PyObject *resultobj = 0;
7961 wxRect *arg1 = (wxRect *) 0 ;
7962 wxRect *arg2 = (wxRect *) 0 ;
7963 PyObject *result = 0 ;
7964 void *argp1 = 0 ;
7965 int res1 = 0 ;
7966 void *argp2 = 0 ;
7967 int res2 = 0 ;
7968 PyObject * obj0 = 0 ;
7969 PyObject * obj1 = 0 ;
7970 char * kwnames[] = {
7971 (char *) "r1",(char *) "r2", NULL
7972 };
7973
7974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7976 if (!SWIG_IsOK(res1)) {
7977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7978 }
7979 arg1 = reinterpret_cast< wxRect * >(argp1);
7980 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7981 if (!SWIG_IsOK(res2)) {
7982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7983 }
7984 arg2 = reinterpret_cast< wxRect * >(argp2);
7985 {
7986 if (!wxPyCheckForApp()) SWIG_fail;
7987 PyThreadState* __tstate = wxPyBeginAllowThreads();
7988 result = (PyObject *)wxIntersectRect(arg1,arg2);
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 resultobj = result;
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8000 PyObject *resultobj = 0;
8001 double arg1 = (double) 0.0 ;
8002 double arg2 = (double) 0.0 ;
8003 wxPoint2D *result = 0 ;
8004 double val1 ;
8005 int ecode1 = 0 ;
8006 double val2 ;
8007 int ecode2 = 0 ;
8008 PyObject * obj0 = 0 ;
8009 PyObject * obj1 = 0 ;
8010 char * kwnames[] = {
8011 (char *) "x",(char *) "y", NULL
8012 };
8013
8014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8015 if (obj0) {
8016 ecode1 = SWIG_AsVal_double(obj0, &val1);
8017 if (!SWIG_IsOK(ecode1)) {
8018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8019 }
8020 arg1 = static_cast< double >(val1);
8021 }
8022 if (obj1) {
8023 ecode2 = SWIG_AsVal_double(obj1, &val2);
8024 if (!SWIG_IsOK(ecode2)) {
8025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8026 }
8027 arg2 = static_cast< double >(val2);
8028 }
8029 {
8030 PyThreadState* __tstate = wxPyBeginAllowThreads();
8031 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8032 wxPyEndAllowThreads(__tstate);
8033 if (PyErr_Occurred()) SWIG_fail;
8034 }
8035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8036 return resultobj;
8037 fail:
8038 return NULL;
8039 }
8040
8041
8042 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8043 PyObject *resultobj = 0;
8044 wxPoint2D *arg1 = 0 ;
8045 wxPoint2D *result = 0 ;
8046 wxPoint2D temp1 ;
8047 PyObject * obj0 = 0 ;
8048 char * kwnames[] = {
8049 (char *) "pt", NULL
8050 };
8051
8052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8053 {
8054 arg1 = &temp1;
8055 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8056 }
8057 {
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj = 0;
8072 wxPoint *arg1 = 0 ;
8073 wxPoint2D *result = 0 ;
8074 wxPoint temp1 ;
8075 PyObject * obj0 = 0 ;
8076 char * kwnames[] = {
8077 (char *) "pt", NULL
8078 };
8079
8080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8081 {
8082 arg1 = &temp1;
8083 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8084 }
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *resultobj = 0;
8100 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8101 int *arg2 = (int *) 0 ;
8102 int *arg3 = (int *) 0 ;
8103 void *argp1 = 0 ;
8104 int res1 = 0 ;
8105 int temp2 ;
8106 int res2 = SWIG_TMPOBJ ;
8107 int temp3 ;
8108 int res3 = SWIG_TMPOBJ ;
8109 PyObject *swig_obj[1] ;
8110
8111 arg2 = &temp2;
8112 arg3 = &temp3;
8113 if (!args) SWIG_fail;
8114 swig_obj[0] = args;
8115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8116 if (!SWIG_IsOK(res1)) {
8117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8118 }
8119 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8120 {
8121 PyThreadState* __tstate = wxPyBeginAllowThreads();
8122 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8123 wxPyEndAllowThreads(__tstate);
8124 if (PyErr_Occurred()) SWIG_fail;
8125 }
8126 resultobj = SWIG_Py_Void();
8127 if (SWIG_IsTmpObj(res2)) {
8128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8129 } else {
8130 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8132 }
8133 if (SWIG_IsTmpObj(res3)) {
8134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8135 } else {
8136 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8138 }
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8148 int *arg2 = (int *) 0 ;
8149 int *arg3 = (int *) 0 ;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 int temp2 ;
8153 int res2 = SWIG_TMPOBJ ;
8154 int temp3 ;
8155 int res3 = SWIG_TMPOBJ ;
8156 PyObject *swig_obj[1] ;
8157
8158 arg2 = &temp2;
8159 arg3 = &temp3;
8160 if (!args) SWIG_fail;
8161 swig_obj[0] = args;
8162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8163 if (!SWIG_IsOK(res1)) {
8164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8165 }
8166 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8167 {
8168 PyThreadState* __tstate = wxPyBeginAllowThreads();
8169 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8170 wxPyEndAllowThreads(__tstate);
8171 if (PyErr_Occurred()) SWIG_fail;
8172 }
8173 resultobj = SWIG_Py_Void();
8174 if (SWIG_IsTmpObj(res2)) {
8175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8176 } else {
8177 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8179 }
8180 if (SWIG_IsTmpObj(res3)) {
8181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8182 } else {
8183 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8185 }
8186 return resultobj;
8187 fail:
8188 return NULL;
8189 }
8190
8191
8192 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8193 PyObject *resultobj = 0;
8194 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8195 double result;
8196 void *argp1 = 0 ;
8197 int res1 = 0 ;
8198 PyObject *swig_obj[1] ;
8199
8200 if (!args) SWIG_fail;
8201 swig_obj[0] = args;
8202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8203 if (!SWIG_IsOK(res1)) {
8204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8205 }
8206 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 resultobj = SWIG_From_double(static_cast< double >(result));
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8221 PyObject *resultobj = 0;
8222 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8223 double result;
8224 void *argp1 = 0 ;
8225 int res1 = 0 ;
8226 PyObject *swig_obj[1] ;
8227
8228 if (!args) SWIG_fail;
8229 swig_obj[0] = args;
8230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8231 if (!SWIG_IsOK(res1)) {
8232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8233 }
8234 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8235 {
8236 PyThreadState* __tstate = wxPyBeginAllowThreads();
8237 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8238 wxPyEndAllowThreads(__tstate);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_From_double(static_cast< double >(result));
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj = 0;
8250 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8251 double arg2 ;
8252 void *argp1 = 0 ;
8253 int res1 = 0 ;
8254 double val2 ;
8255 int ecode2 = 0 ;
8256 PyObject * obj0 = 0 ;
8257 PyObject * obj1 = 0 ;
8258 char * kwnames[] = {
8259 (char *) "self",(char *) "length", NULL
8260 };
8261
8262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8264 if (!SWIG_IsOK(res1)) {
8265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8266 }
8267 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8268 ecode2 = SWIG_AsVal_double(obj1, &val2);
8269 if (!SWIG_IsOK(ecode2)) {
8270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8271 }
8272 arg2 = static_cast< double >(val2);
8273 {
8274 PyThreadState* __tstate = wxPyBeginAllowThreads();
8275 (arg1)->SetVectorLength(arg2);
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 resultobj = SWIG_Py_Void();
8280 return resultobj;
8281 fail:
8282 return NULL;
8283 }
8284
8285
8286 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8287 PyObject *resultobj = 0;
8288 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8289 double arg2 ;
8290 void *argp1 = 0 ;
8291 int res1 = 0 ;
8292 double val2 ;
8293 int ecode2 = 0 ;
8294 PyObject * obj0 = 0 ;
8295 PyObject * obj1 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "self",(char *) "degrees", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8302 if (!SWIG_IsOK(res1)) {
8303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8304 }
8305 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8306 ecode2 = SWIG_AsVal_double(obj1, &val2);
8307 if (!SWIG_IsOK(ecode2)) {
8308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8309 }
8310 arg2 = static_cast< double >(val2);
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 (arg1)->SetVectorAngle(arg2);
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_Py_Void();
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8327 wxPoint2D *arg2 = 0 ;
8328 double result;
8329 void *argp1 = 0 ;
8330 int res1 = 0 ;
8331 wxPoint2D temp2 ;
8332 PyObject * obj0 = 0 ;
8333 PyObject * obj1 = 0 ;
8334 char * kwnames[] = {
8335 (char *) "self",(char *) "pt", NULL
8336 };
8337
8338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8340 if (!SWIG_IsOK(res1)) {
8341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8342 }
8343 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8344 {
8345 arg2 = &temp2;
8346 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8347 }
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_From_double(static_cast< double >(result));
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8364 wxPoint2D *arg2 = 0 ;
8365 double result;
8366 void *argp1 = 0 ;
8367 int res1 = 0 ;
8368 wxPoint2D temp2 ;
8369 PyObject * obj0 = 0 ;
8370 PyObject * obj1 = 0 ;
8371 char * kwnames[] = {
8372 (char *) "self",(char *) "pt", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8377 if (!SWIG_IsOK(res1)) {
8378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8379 }
8380 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8381 {
8382 arg2 = &temp2;
8383 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_From_double(static_cast< double >(result));
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(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 *) "vec", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",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_GetDotProduct" "', 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)->GetDotProduct((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_GetCrossProduct(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 *) "vec", NULL
8447 };
8448
8449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",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_GetCrossProduct" "', 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)->GetCrossProduct((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___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8473 PyObject *resultobj = 0;
8474 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8475 wxPoint2D result;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 PyObject *swig_obj[1] ;
8479
8480 if (!args) SWIG_fail;
8481 swig_obj[0] = args;
8482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8485 }
8486 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (arg1)->operator -();
8490 wxPyEndAllowThreads(__tstate);
8491 if (PyErr_Occurred()) SWIG_fail;
8492 }
8493 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8494 return resultobj;
8495 fail:
8496 return NULL;
8497 }
8498
8499
8500 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8501 PyObject *resultobj = 0;
8502 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8503 wxPoint2D *arg2 = 0 ;
8504 wxPoint2D *result = 0 ;
8505 void *argp1 = 0 ;
8506 int res1 = 0 ;
8507 wxPoint2D temp2 ;
8508 PyObject * obj0 = 0 ;
8509 PyObject * obj1 = 0 ;
8510 char * kwnames[] = {
8511 (char *) "self",(char *) "pt", NULL
8512 };
8513
8514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8516 if (!SWIG_IsOK(res1)) {
8517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8518 }
8519 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8520 {
8521 arg2 = &temp2;
8522 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8523 }
8524 {
8525 PyThreadState* __tstate = wxPyBeginAllowThreads();
8526 {
8527 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8528 result = (wxPoint2D *) &_result_ref;
8529 }
8530 wxPyEndAllowThreads(__tstate);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj = 0;
8542 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8543 wxPoint2D *arg2 = 0 ;
8544 wxPoint2D *result = 0 ;
8545 void *argp1 = 0 ;
8546 int res1 = 0 ;
8547 wxPoint2D temp2 ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 char * kwnames[] = {
8551 (char *) "self",(char *) "pt", NULL
8552 };
8553
8554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 arg2 = &temp2;
8562 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8563 }
8564 {
8565 PyThreadState* __tstate = wxPyBeginAllowThreads();
8566 {
8567 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8568 result = (wxPoint2D *) &_result_ref;
8569 }
8570 wxPyEndAllowThreads(__tstate);
8571 if (PyErr_Occurred()) SWIG_fail;
8572 }
8573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8574 return resultobj;
8575 fail:
8576 return NULL;
8577 }
8578
8579
8580 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8581 PyObject *resultobj = 0;
8582 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8583 wxPoint2D *arg2 = 0 ;
8584 wxPoint2D *result = 0 ;
8585 void *argp1 = 0 ;
8586 int res1 = 0 ;
8587 wxPoint2D temp2 ;
8588 PyObject * obj0 = 0 ;
8589 PyObject * obj1 = 0 ;
8590 char * kwnames[] = {
8591 (char *) "self",(char *) "pt", NULL
8592 };
8593
8594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8596 if (!SWIG_IsOK(res1)) {
8597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8598 }
8599 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8600 {
8601 arg2 = &temp2;
8602 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8603 }
8604 {
8605 PyThreadState* __tstate = wxPyBeginAllowThreads();
8606 {
8607 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8608 result = (wxPoint2D *) &_result_ref;
8609 }
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8621 PyObject *resultobj = 0;
8622 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8623 wxPoint2D *arg2 = 0 ;
8624 wxPoint2D *result = 0 ;
8625 void *argp1 = 0 ;
8626 int res1 = 0 ;
8627 wxPoint2D temp2 ;
8628 PyObject * obj0 = 0 ;
8629 PyObject * obj1 = 0 ;
8630 char * kwnames[] = {
8631 (char *) "self",(char *) "pt", NULL
8632 };
8633
8634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8636 if (!SWIG_IsOK(res1)) {
8637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8638 }
8639 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8640 {
8641 arg2 = &temp2;
8642 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8643 }
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 {
8647 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8648 result = (wxPoint2D *) &_result_ref;
8649 }
8650 wxPyEndAllowThreads(__tstate);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = 0;
8662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8663 PyObject *arg2 = (PyObject *) 0 ;
8664 bool result;
8665 void *argp1 = 0 ;
8666 int res1 = 0 ;
8667 PyObject * obj0 = 0 ;
8668 PyObject * obj1 = 0 ;
8669 char * kwnames[] = {
8670 (char *) "self",(char *) "other", NULL
8671 };
8672
8673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8675 if (!SWIG_IsOK(res1)) {
8676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8677 }
8678 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8679 arg2 = obj1;
8680 {
8681 result = (bool)wxPoint2D___eq__(arg1,arg2);
8682 if (PyErr_Occurred()) SWIG_fail;
8683 }
8684 {
8685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8686 }
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 PyObject *arg2 = (PyObject *) 0 ;
8697 bool result;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 PyObject * obj0 = 0 ;
8701 PyObject * obj1 = 0 ;
8702 char * kwnames[] = {
8703 (char *) "self",(char *) "other", NULL
8704 };
8705
8706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8708 if (!SWIG_IsOK(res1)) {
8709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8710 }
8711 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8712 arg2 = obj1;
8713 {
8714 result = (bool)wxPoint2D___ne__(arg1,arg2);
8715 if (PyErr_Occurred()) SWIG_fail;
8716 }
8717 {
8718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8719 }
8720 return resultobj;
8721 fail:
8722 return NULL;
8723 }
8724
8725
8726 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8727 PyObject *resultobj = 0;
8728 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8729 double arg2 ;
8730 void *argp1 = 0 ;
8731 int res1 = 0 ;
8732 double val2 ;
8733 int ecode2 = 0 ;
8734 PyObject *swig_obj[2] ;
8735
8736 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8738 if (!SWIG_IsOK(res1)) {
8739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8740 }
8741 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8742 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8743 if (!SWIG_IsOK(ecode2)) {
8744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8745 }
8746 arg2 = static_cast< double >(val2);
8747 if (arg1) (arg1)->m_x = arg2;
8748
8749 resultobj = SWIG_Py_Void();
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8757 PyObject *resultobj = 0;
8758 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8759 double result;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 PyObject *swig_obj[1] ;
8763
8764 if (!args) SWIG_fail;
8765 swig_obj[0] = args;
8766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8769 }
8770 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8771 result = (double) ((arg1)->m_x);
8772 resultobj = SWIG_From_double(static_cast< double >(result));
8773 return resultobj;
8774 fail:
8775 return NULL;
8776 }
8777
8778
8779 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8780 PyObject *resultobj = 0;
8781 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8782 double arg2 ;
8783 void *argp1 = 0 ;
8784 int res1 = 0 ;
8785 double val2 ;
8786 int ecode2 = 0 ;
8787 PyObject *swig_obj[2] ;
8788
8789 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8791 if (!SWIG_IsOK(res1)) {
8792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8793 }
8794 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8795 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8796 if (!SWIG_IsOK(ecode2)) {
8797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8798 }
8799 arg2 = static_cast< double >(val2);
8800 if (arg1) (arg1)->m_y = arg2;
8801
8802 resultobj = SWIG_Py_Void();
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8810 PyObject *resultobj = 0;
8811 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8812 double result;
8813 void *argp1 = 0 ;
8814 int res1 = 0 ;
8815 PyObject *swig_obj[1] ;
8816
8817 if (!args) SWIG_fail;
8818 swig_obj[0] = args;
8819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8820 if (!SWIG_IsOK(res1)) {
8821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8822 }
8823 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8824 result = (double) ((arg1)->m_y);
8825 resultobj = SWIG_From_double(static_cast< double >(result));
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
8832 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj = 0;
8834 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8835 double arg2 = (double) 0 ;
8836 double arg3 = (double) 0 ;
8837 void *argp1 = 0 ;
8838 int res1 = 0 ;
8839 double val2 ;
8840 int ecode2 = 0 ;
8841 double val3 ;
8842 int ecode3 = 0 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 PyObject * obj2 = 0 ;
8846 char * kwnames[] = {
8847 (char *) "self",(char *) "x",(char *) "y", NULL
8848 };
8849
8850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 if (obj1) {
8857 ecode2 = SWIG_AsVal_double(obj1, &val2);
8858 if (!SWIG_IsOK(ecode2)) {
8859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8860 }
8861 arg2 = static_cast< double >(val2);
8862 }
8863 if (obj2) {
8864 ecode3 = SWIG_AsVal_double(obj2, &val3);
8865 if (!SWIG_IsOK(ecode3)) {
8866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8867 }
8868 arg3 = static_cast< double >(val3);
8869 }
8870 {
8871 PyThreadState* __tstate = wxPyBeginAllowThreads();
8872 wxPoint2D_Set(arg1,arg2,arg3);
8873 wxPyEndAllowThreads(__tstate);
8874 if (PyErr_Occurred()) SWIG_fail;
8875 }
8876 resultobj = SWIG_Py_Void();
8877 return resultobj;
8878 fail:
8879 return NULL;
8880 }
8881
8882
8883 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8884 PyObject *resultobj = 0;
8885 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8886 PyObject *result = 0 ;
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_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8896 }
8897 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 result = (PyObject *)wxPoint2D_Get(arg1);
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 resultobj = result;
8905 return resultobj;
8906 fail:
8907 return NULL;
8908 }
8909
8910
8911 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8912 PyObject *obj;
8913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8914 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8915 return SWIG_Py_Void();
8916 }
8917
8918 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8919 return SWIG_Python_InitShadowInstance(args);
8920 }
8921
8922 SWIGINTERN int DefaultPosition_set(PyObject *) {
8923 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8924 return 1;
8925 }
8926
8927
8928 SWIGINTERN PyObject *DefaultPosition_get(void) {
8929 PyObject *pyobj = 0;
8930
8931 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8932 return pyobj;
8933 }
8934
8935
8936 SWIGINTERN int DefaultSize_set(PyObject *) {
8937 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8938 return 1;
8939 }
8940
8941
8942 SWIGINTERN PyObject *DefaultSize_get(void) {
8943 PyObject *pyobj = 0;
8944
8945 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8946 return pyobj;
8947 }
8948
8949
8950 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8951 PyObject *resultobj = 0;
8952 PyObject *arg1 = (PyObject *) 0 ;
8953 wxPyInputStream *result = 0 ;
8954 PyObject * obj0 = 0 ;
8955 char * kwnames[] = {
8956 (char *) "p", NULL
8957 };
8958
8959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8960 arg1 = obj0;
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8975 PyObject *resultobj = 0;
8976 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8977 void *argp1 = 0 ;
8978 int res1 = 0 ;
8979 PyObject *swig_obj[1] ;
8980
8981 if (!args) SWIG_fail;
8982 swig_obj[0] = args;
8983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8984 if (!SWIG_IsOK(res1)) {
8985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8986 }
8987 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 delete arg1;
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 resultobj = SWIG_Py_Void();
8996 return resultobj;
8997 fail:
8998 return NULL;
8999 }
9000
9001
9002 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9003 PyObject *resultobj = 0;
9004 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9005 void *argp1 = 0 ;
9006 int res1 = 0 ;
9007 PyObject *swig_obj[1] ;
9008
9009 if (!args) SWIG_fail;
9010 swig_obj[0] = args;
9011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9012 if (!SWIG_IsOK(res1)) {
9013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9014 }
9015 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9016 {
9017 PyThreadState* __tstate = wxPyBeginAllowThreads();
9018 (arg1)->close();
9019 wxPyEndAllowThreads(__tstate);
9020 if (PyErr_Occurred()) SWIG_fail;
9021 }
9022 resultobj = SWIG_Py_Void();
9023 return resultobj;
9024 fail:
9025 return NULL;
9026 }
9027
9028
9029 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030 PyObject *resultobj = 0;
9031 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9032 void *argp1 = 0 ;
9033 int res1 = 0 ;
9034 PyObject *swig_obj[1] ;
9035
9036 if (!args) SWIG_fail;
9037 swig_obj[0] = args;
9038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9039 if (!SWIG_IsOK(res1)) {
9040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9041 }
9042 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9043 {
9044 PyThreadState* __tstate = wxPyBeginAllowThreads();
9045 (arg1)->flush();
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 resultobj = SWIG_Py_Void();
9050 return resultobj;
9051 fail:
9052 return NULL;
9053 }
9054
9055
9056 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9057 PyObject *resultobj = 0;
9058 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9059 bool result;
9060 void *argp1 = 0 ;
9061 int res1 = 0 ;
9062 PyObject *swig_obj[1] ;
9063
9064 if (!args) SWIG_fail;
9065 swig_obj[0] = args;
9066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9069 }
9070 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9071 {
9072 PyThreadState* __tstate = wxPyBeginAllowThreads();
9073 result = (bool)(arg1)->eof();
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 {
9078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9079 }
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj = 0;
9088 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9089 int arg2 = (int) -1 ;
9090 PyObject *result = 0 ;
9091 void *argp1 = 0 ;
9092 int res1 = 0 ;
9093 int val2 ;
9094 int ecode2 = 0 ;
9095 PyObject * obj0 = 0 ;
9096 PyObject * obj1 = 0 ;
9097 char * kwnames[] = {
9098 (char *) "self",(char *) "size", NULL
9099 };
9100
9101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9103 if (!SWIG_IsOK(res1)) {
9104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9105 }
9106 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9107 if (obj1) {
9108 ecode2 = SWIG_AsVal_int(obj1, &val2);
9109 if (!SWIG_IsOK(ecode2)) {
9110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9111 }
9112 arg2 = static_cast< int >(val2);
9113 }
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 result = (PyObject *)(arg1)->read(arg2);
9117 wxPyEndAllowThreads(__tstate);
9118 if (PyErr_Occurred()) SWIG_fail;
9119 }
9120 resultobj = result;
9121 return resultobj;
9122 fail:
9123 return NULL;
9124 }
9125
9126
9127 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9128 PyObject *resultobj = 0;
9129 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9130 int arg2 = (int) -1 ;
9131 PyObject *result = 0 ;
9132 void *argp1 = 0 ;
9133 int res1 = 0 ;
9134 int val2 ;
9135 int ecode2 = 0 ;
9136 PyObject * obj0 = 0 ;
9137 PyObject * obj1 = 0 ;
9138 char * kwnames[] = {
9139 (char *) "self",(char *) "size", NULL
9140 };
9141
9142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9144 if (!SWIG_IsOK(res1)) {
9145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9146 }
9147 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9148 if (obj1) {
9149 ecode2 = SWIG_AsVal_int(obj1, &val2);
9150 if (!SWIG_IsOK(ecode2)) {
9151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9152 }
9153 arg2 = static_cast< int >(val2);
9154 }
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (PyObject *)(arg1)->readline(arg2);
9158 wxPyEndAllowThreads(__tstate);
9159 if (PyErr_Occurred()) SWIG_fail;
9160 }
9161 resultobj = result;
9162 return resultobj;
9163 fail:
9164 return NULL;
9165 }
9166
9167
9168 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9169 PyObject *resultobj = 0;
9170 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9171 int arg2 = (int) -1 ;
9172 PyObject *result = 0 ;
9173 void *argp1 = 0 ;
9174 int res1 = 0 ;
9175 int val2 ;
9176 int ecode2 = 0 ;
9177 PyObject * obj0 = 0 ;
9178 PyObject * obj1 = 0 ;
9179 char * kwnames[] = {
9180 (char *) "self",(char *) "sizehint", NULL
9181 };
9182
9183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 if (obj1) {
9190 ecode2 = SWIG_AsVal_int(obj1, &val2);
9191 if (!SWIG_IsOK(ecode2)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9193 }
9194 arg2 = static_cast< int >(val2);
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 result = (PyObject *)(arg1)->readlines(arg2);
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 resultobj = result;
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9210 PyObject *resultobj = 0;
9211 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9212 int arg2 ;
9213 int arg3 = (int) 0 ;
9214 void *argp1 = 0 ;
9215 int res1 = 0 ;
9216 int val2 ;
9217 int ecode2 = 0 ;
9218 int val3 ;
9219 int ecode3 = 0 ;
9220 PyObject * obj0 = 0 ;
9221 PyObject * obj1 = 0 ;
9222 PyObject * obj2 = 0 ;
9223 char * kwnames[] = {
9224 (char *) "self",(char *) "offset",(char *) "whence", NULL
9225 };
9226
9227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9231 }
9232 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9233 ecode2 = SWIG_AsVal_int(obj1, &val2);
9234 if (!SWIG_IsOK(ecode2)) {
9235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9236 }
9237 arg2 = static_cast< int >(val2);
9238 if (obj2) {
9239 ecode3 = SWIG_AsVal_int(obj2, &val3);
9240 if (!SWIG_IsOK(ecode3)) {
9241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9242 }
9243 arg3 = static_cast< int >(val3);
9244 }
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 (arg1)->seek(arg2,arg3);
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 resultobj = SWIG_Py_Void();
9252 return resultobj;
9253 fail:
9254 return NULL;
9255 }
9256
9257
9258 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9261 int result;
9262 void *argp1 = 0 ;
9263 int res1 = 0 ;
9264 PyObject *swig_obj[1] ;
9265
9266 if (!args) SWIG_fail;
9267 swig_obj[0] = args;
9268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9269 if (!SWIG_IsOK(res1)) {
9270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9271 }
9272 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (int)(arg1)->tell();
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 resultobj = SWIG_From_int(static_cast< int >(result));
9280 return resultobj;
9281 fail:
9282 return NULL;
9283 }
9284
9285
9286 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9287 PyObject *resultobj = 0;
9288 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9289 char result;
9290 void *argp1 = 0 ;
9291 int res1 = 0 ;
9292 PyObject *swig_obj[1] ;
9293
9294 if (!args) SWIG_fail;
9295 swig_obj[0] = args;
9296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9297 if (!SWIG_IsOK(res1)) {
9298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9299 }
9300 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9301 {
9302 PyThreadState* __tstate = wxPyBeginAllowThreads();
9303 result = (char)(arg1)->Peek();
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 resultobj = SWIG_From_char(static_cast< char >(result));
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9315 PyObject *resultobj = 0;
9316 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9317 char result;
9318 void *argp1 = 0 ;
9319 int res1 = 0 ;
9320 PyObject *swig_obj[1] ;
9321
9322 if (!args) SWIG_fail;
9323 swig_obj[0] = args;
9324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9325 if (!SWIG_IsOK(res1)) {
9326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9327 }
9328 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9329 {
9330 PyThreadState* __tstate = wxPyBeginAllowThreads();
9331 result = (char)(arg1)->GetC();
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 resultobj = SWIG_From_char(static_cast< char >(result));
9336 return resultobj;
9337 fail:
9338 return NULL;
9339 }
9340
9341
9342 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9343 PyObject *resultobj = 0;
9344 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9345 size_t result;
9346 void *argp1 = 0 ;
9347 int res1 = 0 ;
9348 PyObject *swig_obj[1] ;
9349
9350 if (!args) SWIG_fail;
9351 swig_obj[0] = args;
9352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9353 if (!SWIG_IsOK(res1)) {
9354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9355 }
9356 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (size_t)(arg1)->LastRead();
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9371 PyObject *resultobj = 0;
9372 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9373 bool result;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 PyObject *swig_obj[1] ;
9377
9378 if (!args) SWIG_fail;
9379 swig_obj[0] = args;
9380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9383 }
9384 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 result = (bool)(arg1)->CanRead();
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 {
9392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9393 }
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9401 PyObject *resultobj = 0;
9402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9403 bool result;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 PyObject *swig_obj[1] ;
9407
9408 if (!args) SWIG_fail;
9409 swig_obj[0] = args;
9410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9413 }
9414 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (bool)(arg1)->Eof();
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9423 }
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj = 0;
9432 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9433 char arg2 ;
9434 bool result;
9435 void *argp1 = 0 ;
9436 int res1 = 0 ;
9437 char val2 ;
9438 int ecode2 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 char * kwnames[] = {
9442 (char *) "self",(char *) "c", NULL
9443 };
9444
9445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9447 if (!SWIG_IsOK(res1)) {
9448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9449 }
9450 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9451 ecode2 = SWIG_AsVal_char(obj1, &val2);
9452 if (!SWIG_IsOK(ecode2)) {
9453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9454 }
9455 arg2 = static_cast< char >(val2);
9456 {
9457 PyThreadState* __tstate = wxPyBeginAllowThreads();
9458 result = (bool)(arg1)->Ungetch(arg2);
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 {
9463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9464 }
9465 return resultobj;
9466 fail:
9467 return NULL;
9468 }
9469
9470
9471 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9472 PyObject *resultobj = 0;
9473 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9474 long arg2 ;
9475 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9476 long result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 long val2 ;
9480 int ecode2 = 0 ;
9481 int val3 ;
9482 int ecode3 = 0 ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 PyObject * obj2 = 0 ;
9486 char * kwnames[] = {
9487 (char *) "self",(char *) "pos",(char *) "mode", NULL
9488 };
9489
9490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9492 if (!SWIG_IsOK(res1)) {
9493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9494 }
9495 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9496 ecode2 = SWIG_AsVal_long(obj1, &val2);
9497 if (!SWIG_IsOK(ecode2)) {
9498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9499 }
9500 arg2 = static_cast< long >(val2);
9501 if (obj2) {
9502 ecode3 = SWIG_AsVal_int(obj2, &val3);
9503 if (!SWIG_IsOK(ecode3)) {
9504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9505 }
9506 arg3 = static_cast< wxSeekMode >(val3);
9507 }
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 result = (long)(arg1)->SeekI(arg2,arg3);
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_From_long(static_cast< long >(result));
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9522 PyObject *resultobj = 0;
9523 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9524 long result;
9525 void *argp1 = 0 ;
9526 int res1 = 0 ;
9527 PyObject *swig_obj[1] ;
9528
9529 if (!args) SWIG_fail;
9530 swig_obj[0] = args;
9531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9534 }
9535 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = (long)(arg1)->TellI();
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_From_long(static_cast< long >(result));
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9550 PyObject *obj;
9551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9552 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9553 return SWIG_Py_Void();
9554 }
9555
9556 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9557 return SWIG_Python_InitShadowInstance(args);
9558 }
9559
9560 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj = 0;
9562 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9563 PyObject *arg2 = (PyObject *) 0 ;
9564 void *argp1 = 0 ;
9565 int res1 = 0 ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char * kwnames[] = {
9569 (char *) "self",(char *) "obj", NULL
9570 };
9571
9572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9576 }
9577 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9578 arg2 = obj1;
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 wxOutputStream_write(arg1,arg2);
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 resultobj = SWIG_Py_Void();
9586 return resultobj;
9587 fail:
9588 return NULL;
9589 }
9590
9591
9592 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9593 PyObject *resultobj = 0;
9594 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9595 size_t result;
9596 void *argp1 = 0 ;
9597 int res1 = 0 ;
9598 PyObject *swig_obj[1] ;
9599
9600 if (!args) SWIG_fail;
9601 swig_obj[0] = args;
9602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9605 }
9606 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9614 return resultobj;
9615 fail:
9616 return NULL;
9617 }
9618
9619
9620 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9621 PyObject *obj;
9622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9623 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9624 return SWIG_Py_Void();
9625 }
9626
9627 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9628 PyObject *resultobj = 0;
9629 wxInputStream *arg1 = (wxInputStream *) 0 ;
9630 wxString *arg2 = 0 ;
9631 wxString *arg3 = 0 ;
9632 wxString *arg4 = 0 ;
9633 wxDateTime arg5 ;
9634 wxFSFile *result = 0 ;
9635 wxPyInputStream *temp1 ;
9636 bool temp2 = false ;
9637 bool temp3 = false ;
9638 bool temp4 = false ;
9639 void *argp5 ;
9640 int res5 = 0 ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 PyObject * obj2 = 0 ;
9644 PyObject * obj3 = 0 ;
9645 PyObject * obj4 = 0 ;
9646 char * kwnames[] = {
9647 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9648 };
9649
9650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9651 {
9652 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9653 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9654 } else {
9655 PyErr_Clear(); // clear the failure of the wxPyConvert above
9656 arg1 = wxPyCBInputStream_create(obj0, true);
9657 if (arg1 == NULL) {
9658 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9659 SWIG_fail;
9660 }
9661 }
9662 }
9663 {
9664 arg2 = wxString_in_helper(obj1);
9665 if (arg2 == NULL) SWIG_fail;
9666 temp2 = true;
9667 }
9668 {
9669 arg3 = wxString_in_helper(obj2);
9670 if (arg3 == NULL) SWIG_fail;
9671 temp3 = true;
9672 }
9673 {
9674 arg4 = wxString_in_helper(obj3);
9675 if (arg4 == NULL) SWIG_fail;
9676 temp4 = true;
9677 }
9678 {
9679 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9680 if (!SWIG_IsOK(res5)) {
9681 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9682 }
9683 if (!argp5) {
9684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9685 } else {
9686 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9687 arg5 = *temp;
9688 if (SWIG_IsNewObj(res5)) delete temp;
9689 }
9690 }
9691 {
9692 PyThreadState* __tstate = wxPyBeginAllowThreads();
9693 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9698 {
9699 if (temp2)
9700 delete arg2;
9701 }
9702 {
9703 if (temp3)
9704 delete arg3;
9705 }
9706 {
9707 if (temp4)
9708 delete arg4;
9709 }
9710 return resultobj;
9711 fail:
9712 {
9713 if (temp2)
9714 delete arg2;
9715 }
9716 {
9717 if (temp3)
9718 delete arg3;
9719 }
9720 {
9721 if (temp4)
9722 delete arg4;
9723 }
9724 return NULL;
9725 }
9726
9727
9728 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9729 PyObject *resultobj = 0;
9730 wxFSFile *arg1 = (wxFSFile *) 0 ;
9731 void *argp1 = 0 ;
9732 int res1 = 0 ;
9733 PyObject *swig_obj[1] ;
9734
9735 if (!args) SWIG_fail;
9736 swig_obj[0] = args;
9737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9738 if (!SWIG_IsOK(res1)) {
9739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9740 }
9741 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9742 {
9743 PyThreadState* __tstate = wxPyBeginAllowThreads();
9744 delete arg1;
9745
9746 wxPyEndAllowThreads(__tstate);
9747 if (PyErr_Occurred()) SWIG_fail;
9748 }
9749 resultobj = SWIG_Py_Void();
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
9756 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9757 PyObject *resultobj = 0;
9758 wxFSFile *arg1 = (wxFSFile *) 0 ;
9759 wxInputStream *result = 0 ;
9760 void *argp1 = 0 ;
9761 int res1 = 0 ;
9762 PyObject *swig_obj[1] ;
9763
9764 if (!args) SWIG_fail;
9765 swig_obj[0] = args;
9766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9769 }
9770 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9771 {
9772 PyThreadState* __tstate = wxPyBeginAllowThreads();
9773 result = (wxInputStream *)(arg1)->GetStream();
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 {
9778 wxPyInputStream * _ptr = NULL;
9779
9780 if (result) {
9781 _ptr = new wxPyInputStream(result);
9782 }
9783 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9784 }
9785 return resultobj;
9786 fail:
9787 return NULL;
9788 }
9789
9790
9791 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9792 PyObject *resultobj = 0;
9793 wxFSFile *arg1 = (wxFSFile *) 0 ;
9794 wxString *result = 0 ;
9795 void *argp1 = 0 ;
9796 int res1 = 0 ;
9797 PyObject *swig_obj[1] ;
9798
9799 if (!args) SWIG_fail;
9800 swig_obj[0] = args;
9801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9804 }
9805 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 {
9809 wxString const &_result_ref = (arg1)->GetMimeType();
9810 result = (wxString *) &_result_ref;
9811 }
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 #if wxUSE_UNICODE
9817 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9818 #else
9819 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9820 #endif
9821 }
9822 return resultobj;
9823 fail:
9824 return NULL;
9825 }
9826
9827
9828 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9829 PyObject *resultobj = 0;
9830 wxFSFile *arg1 = (wxFSFile *) 0 ;
9831 wxString *result = 0 ;
9832 void *argp1 = 0 ;
9833 int res1 = 0 ;
9834 PyObject *swig_obj[1] ;
9835
9836 if (!args) SWIG_fail;
9837 swig_obj[0] = args;
9838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9839 if (!SWIG_IsOK(res1)) {
9840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9841 }
9842 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 {
9846 wxString const &_result_ref = (arg1)->GetLocation();
9847 result = (wxString *) &_result_ref;
9848 }
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 {
9853 #if wxUSE_UNICODE
9854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9855 #else
9856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9857 #endif
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(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_GetAnchor" "', 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)->GetAnchor();
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_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxFSFile *arg1 = (wxFSFile *) 0 ;
9905 wxDateTime result;
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_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9915 }
9916 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 result = (arg1)->GetModificationTime();
9920 wxPyEndAllowThreads(__tstate);
9921 if (PyErr_Occurred()) SWIG_fail;
9922 }
9923 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *obj;
9932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9933 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9934 return SWIG_Py_Void();
9935 }
9936
9937 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9938 return SWIG_Python_InitShadowInstance(args);
9939 }
9940
9941 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9942 PyObject *resultobj = 0;
9943 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9944 void *argp1 = 0 ;
9945 int res1 = 0 ;
9946 PyObject *swig_obj[1] ;
9947
9948 if (!args) SWIG_fail;
9949 swig_obj[0] = args;
9950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9951 if (!SWIG_IsOK(res1)) {
9952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9953 }
9954 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 delete arg1;
9958
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 resultobj = SWIG_Py_Void();
9963 return resultobj;
9964 fail:
9965 return NULL;
9966 }
9967
9968
9969 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9970 PyObject *obj;
9971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9972 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9973 return SWIG_Py_Void();
9974 }
9975
9976 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9977 PyObject *resultobj = 0;
9978 wxPyFileSystemHandler *result = 0 ;
9979
9980 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9988 return resultobj;
9989 fail:
9990 return NULL;
9991 }
9992
9993
9994 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9995 PyObject *resultobj = 0;
9996 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9997 PyObject *arg2 = (PyObject *) 0 ;
9998 PyObject *arg3 = (PyObject *) 0 ;
9999 void *argp1 = 0 ;
10000 int res1 = 0 ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 PyObject * obj2 = 0 ;
10004 char * kwnames[] = {
10005 (char *) "self",(char *) "self",(char *) "_class", NULL
10006 };
10007
10008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10010 if (!SWIG_IsOK(res1)) {
10011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10012 }
10013 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10014 arg2 = obj1;
10015 arg3 = obj2;
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 (arg1)->_setCallbackInfo(arg2,arg3);
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 resultobj = SWIG_Py_Void();
10023 return resultobj;
10024 fail:
10025 return NULL;
10026 }
10027
10028
10029 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = 0;
10031 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10032 wxString *arg2 = 0 ;
10033 bool result;
10034 void *argp1 = 0 ;
10035 int res1 = 0 ;
10036 bool temp2 = false ;
10037 PyObject * obj0 = 0 ;
10038 PyObject * obj1 = 0 ;
10039 char * kwnames[] = {
10040 (char *) "self",(char *) "location", NULL
10041 };
10042
10043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10047 }
10048 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10049 {
10050 arg2 = wxString_in_helper(obj1);
10051 if (arg2 == NULL) SWIG_fail;
10052 temp2 = true;
10053 }
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 {
10061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10062 }
10063 {
10064 if (temp2)
10065 delete arg2;
10066 }
10067 return resultobj;
10068 fail:
10069 {
10070 if (temp2)
10071 delete arg2;
10072 }
10073 return NULL;
10074 }
10075
10076
10077 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10078 PyObject *resultobj = 0;
10079 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10080 wxFileSystem *arg2 = 0 ;
10081 wxString *arg3 = 0 ;
10082 wxFSFile *result = 0 ;
10083 void *argp1 = 0 ;
10084 int res1 = 0 ;
10085 void *argp2 = 0 ;
10086 int res2 = 0 ;
10087 bool temp3 = false ;
10088 PyObject * obj0 = 0 ;
10089 PyObject * obj1 = 0 ;
10090 PyObject * obj2 = 0 ;
10091 char * kwnames[] = {
10092 (char *) "self",(char *) "fs",(char *) "location", NULL
10093 };
10094
10095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10097 if (!SWIG_IsOK(res1)) {
10098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10099 }
10100 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10102 if (!SWIG_IsOK(res2)) {
10103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10104 }
10105 if (!argp2) {
10106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10107 }
10108 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10109 {
10110 arg3 = wxString_in_helper(obj2);
10111 if (arg3 == NULL) SWIG_fail;
10112 temp3 = true;
10113 }
10114 {
10115 PyThreadState* __tstate = wxPyBeginAllowThreads();
10116 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10117 wxPyEndAllowThreads(__tstate);
10118 if (PyErr_Occurred()) SWIG_fail;
10119 }
10120 {
10121 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10122 }
10123 {
10124 if (temp3)
10125 delete arg3;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp3)
10131 delete arg3;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj = 0;
10139 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10140 wxString *arg2 = 0 ;
10141 int arg3 = (int) 0 ;
10142 wxString result;
10143 void *argp1 = 0 ;
10144 int res1 = 0 ;
10145 bool temp2 = false ;
10146 int val3 ;
10147 int ecode3 = 0 ;
10148 PyObject * obj0 = 0 ;
10149 PyObject * obj1 = 0 ;
10150 PyObject * obj2 = 0 ;
10151 char * kwnames[] = {
10152 (char *) "self",(char *) "spec",(char *) "flags", NULL
10153 };
10154
10155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10157 if (!SWIG_IsOK(res1)) {
10158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10159 }
10160 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10161 {
10162 arg2 = wxString_in_helper(obj1);
10163 if (arg2 == NULL) SWIG_fail;
10164 temp2 = true;
10165 }
10166 if (obj2) {
10167 ecode3 = SWIG_AsVal_int(obj2, &val3);
10168 if (!SWIG_IsOK(ecode3)) {
10169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10170 }
10171 arg3 = static_cast< int >(val3);
10172 }
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 {
10180 #if wxUSE_UNICODE
10181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10182 #else
10183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10184 #endif
10185 }
10186 {
10187 if (temp2)
10188 delete arg2;
10189 }
10190 return resultobj;
10191 fail:
10192 {
10193 if (temp2)
10194 delete arg2;
10195 }
10196 return NULL;
10197 }
10198
10199
10200 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10201 PyObject *resultobj = 0;
10202 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10203 wxString result;
10204 void *argp1 = 0 ;
10205 int res1 = 0 ;
10206 PyObject *swig_obj[1] ;
10207
10208 if (!args) SWIG_fail;
10209 swig_obj[0] = args;
10210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10211 if (!SWIG_IsOK(res1)) {
10212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10213 }
10214 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (arg1)->FindNext();
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 #if wxUSE_UNICODE
10223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10224 #else
10225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10226 #endif
10227 }
10228 return resultobj;
10229 fail:
10230 return NULL;
10231 }
10232
10233
10234 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj = 0;
10236 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10237 wxString *arg2 = 0 ;
10238 wxString result;
10239 void *argp1 = 0 ;
10240 int res1 = 0 ;
10241 bool temp2 = false ;
10242 PyObject * obj0 = 0 ;
10243 PyObject * obj1 = 0 ;
10244 char * kwnames[] = {
10245 (char *) "self",(char *) "location", NULL
10246 };
10247
10248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10250 if (!SWIG_IsOK(res1)) {
10251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10252 }
10253 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10254 {
10255 arg2 = wxString_in_helper(obj1);
10256 if (arg2 == NULL) SWIG_fail;
10257 temp2 = true;
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 result = (arg1)->GetProtocol((wxString const &)*arg2);
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 {
10266 #if wxUSE_UNICODE
10267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10268 #else
10269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10270 #endif
10271 }
10272 {
10273 if (temp2)
10274 delete arg2;
10275 }
10276 return resultobj;
10277 fail:
10278 {
10279 if (temp2)
10280 delete arg2;
10281 }
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj = 0;
10288 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10289 wxString *arg2 = 0 ;
10290 wxString result;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 bool temp2 = false ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char * kwnames[] = {
10297 (char *) "self",(char *) "location", NULL
10298 };
10299
10300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10302 if (!SWIG_IsOK(res1)) {
10303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10304 }
10305 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10306 {
10307 arg2 = wxString_in_helper(obj1);
10308 if (arg2 == NULL) SWIG_fail;
10309 temp2 = true;
10310 }
10311 {
10312 PyThreadState* __tstate = wxPyBeginAllowThreads();
10313 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 {
10318 #if wxUSE_UNICODE
10319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10320 #else
10321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10322 #endif
10323 }
10324 {
10325 if (temp2)
10326 delete arg2;
10327 }
10328 return resultobj;
10329 fail:
10330 {
10331 if (temp2)
10332 delete arg2;
10333 }
10334 return NULL;
10335 }
10336
10337
10338 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10339 PyObject *resultobj = 0;
10340 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10341 wxString *arg2 = 0 ;
10342 wxString result;
10343 void *argp1 = 0 ;
10344 int res1 = 0 ;
10345 bool temp2 = false ;
10346 PyObject * obj0 = 0 ;
10347 PyObject * obj1 = 0 ;
10348 char * kwnames[] = {
10349 (char *) "self",(char *) "location", NULL
10350 };
10351
10352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10354 if (!SWIG_IsOK(res1)) {
10355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10356 }
10357 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10358 {
10359 arg2 = wxString_in_helper(obj1);
10360 if (arg2 == NULL) SWIG_fail;
10361 temp2 = true;
10362 }
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 result = (arg1)->GetAnchor((wxString const &)*arg2);
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 {
10370 #if wxUSE_UNICODE
10371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10372 #else
10373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10374 #endif
10375 }
10376 {
10377 if (temp2)
10378 delete arg2;
10379 }
10380 return resultobj;
10381 fail:
10382 {
10383 if (temp2)
10384 delete arg2;
10385 }
10386 return NULL;
10387 }
10388
10389
10390 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10391 PyObject *resultobj = 0;
10392 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10393 wxString *arg2 = 0 ;
10394 wxString result;
10395 void *argp1 = 0 ;
10396 int res1 = 0 ;
10397 bool temp2 = false ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 char * kwnames[] = {
10401 (char *) "self",(char *) "location", NULL
10402 };
10403
10404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10406 if (!SWIG_IsOK(res1)) {
10407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10408 }
10409 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10410 {
10411 arg2 = wxString_in_helper(obj1);
10412 if (arg2 == NULL) SWIG_fail;
10413 temp2 = true;
10414 }
10415 {
10416 PyThreadState* __tstate = wxPyBeginAllowThreads();
10417 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 #if wxUSE_UNICODE
10423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10424 #else
10425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10426 #endif
10427 }
10428 {
10429 if (temp2)
10430 delete arg2;
10431 }
10432 return resultobj;
10433 fail:
10434 {
10435 if (temp2)
10436 delete arg2;
10437 }
10438 return NULL;
10439 }
10440
10441
10442 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10443 PyObject *resultobj = 0;
10444 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10445 wxString *arg2 = 0 ;
10446 wxString result;
10447 void *argp1 = 0 ;
10448 int res1 = 0 ;
10449 bool temp2 = false ;
10450 PyObject * obj0 = 0 ;
10451 PyObject * obj1 = 0 ;
10452 char * kwnames[] = {
10453 (char *) "self",(char *) "location", NULL
10454 };
10455
10456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10458 if (!SWIG_IsOK(res1)) {
10459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10460 }
10461 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10462 {
10463 arg2 = wxString_in_helper(obj1);
10464 if (arg2 == NULL) SWIG_fail;
10465 temp2 = true;
10466 }
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 {
10474 #if wxUSE_UNICODE
10475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10476 #else
10477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10478 #endif
10479 }
10480 {
10481 if (temp2)
10482 delete arg2;
10483 }
10484 return resultobj;
10485 fail:
10486 {
10487 if (temp2)
10488 delete arg2;
10489 }
10490 return NULL;
10491 }
10492
10493
10494 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10495 PyObject *obj;
10496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10497 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10498 return SWIG_Py_Void();
10499 }
10500
10501 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10502 return SWIG_Python_InitShadowInstance(args);
10503 }
10504
10505 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10506 PyObject *resultobj = 0;
10507 wxFileSystem *result = 0 ;
10508
10509 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (wxFileSystem *)new wxFileSystem();
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10518 }
10519 return resultobj;
10520 fail:
10521 return NULL;
10522 }
10523
10524
10525 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10526 PyObject *resultobj = 0;
10527 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10528 void *argp1 = 0 ;
10529 int res1 = 0 ;
10530 PyObject *swig_obj[1] ;
10531
10532 if (!args) SWIG_fail;
10533 swig_obj[0] = args;
10534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10537 }
10538 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 delete arg1;
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 resultobj = SWIG_Py_Void();
10547 return resultobj;
10548 fail:
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10554 PyObject *resultobj = 0;
10555 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10556 wxString *arg2 = 0 ;
10557 bool arg3 = (bool) false ;
10558 void *argp1 = 0 ;
10559 int res1 = 0 ;
10560 bool temp2 = false ;
10561 bool val3 ;
10562 int ecode3 = 0 ;
10563 PyObject * obj0 = 0 ;
10564 PyObject * obj1 = 0 ;
10565 PyObject * obj2 = 0 ;
10566 char * kwnames[] = {
10567 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10568 };
10569
10570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10572 if (!SWIG_IsOK(res1)) {
10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10574 }
10575 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10576 {
10577 arg2 = wxString_in_helper(obj1);
10578 if (arg2 == NULL) SWIG_fail;
10579 temp2 = true;
10580 }
10581 if (obj2) {
10582 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10583 if (!SWIG_IsOK(ecode3)) {
10584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10585 }
10586 arg3 = static_cast< bool >(val3);
10587 }
10588 {
10589 PyThreadState* __tstate = wxPyBeginAllowThreads();
10590 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10591 wxPyEndAllowThreads(__tstate);
10592 if (PyErr_Occurred()) SWIG_fail;
10593 }
10594 resultobj = SWIG_Py_Void();
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp2)
10603 delete arg2;
10604 }
10605 return NULL;
10606 }
10607
10608
10609 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610 PyObject *resultobj = 0;
10611 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10612 wxString result;
10613 void *argp1 = 0 ;
10614 int res1 = 0 ;
10615 PyObject *swig_obj[1] ;
10616
10617 if (!args) SWIG_fail;
10618 swig_obj[0] = args;
10619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10620 if (!SWIG_IsOK(res1)) {
10621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10622 }
10623 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 result = (arg1)->GetPath();
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 {
10631 #if wxUSE_UNICODE
10632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10633 #else
10634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10635 #endif
10636 }
10637 return resultobj;
10638 fail:
10639 return NULL;
10640 }
10641
10642
10643 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10644 PyObject *resultobj = 0;
10645 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10646 wxString *arg2 = 0 ;
10647 wxFSFile *result = 0 ;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 bool temp2 = false ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 char * kwnames[] = {
10654 (char *) "self",(char *) "location", NULL
10655 };
10656
10657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10659 if (!SWIG_IsOK(res1)) {
10660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10661 }
10662 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10663 {
10664 arg2 = wxString_in_helper(obj1);
10665 if (arg2 == NULL) SWIG_fail;
10666 temp2 = true;
10667 }
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 {
10675 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10676 }
10677 {
10678 if (temp2)
10679 delete arg2;
10680 }
10681 return resultobj;
10682 fail:
10683 {
10684 if (temp2)
10685 delete arg2;
10686 }
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj = 0;
10693 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10694 wxString *arg2 = 0 ;
10695 int arg3 = (int) 0 ;
10696 wxString result;
10697 void *argp1 = 0 ;
10698 int res1 = 0 ;
10699 bool temp2 = false ;
10700 int val3 ;
10701 int ecode3 = 0 ;
10702 PyObject * obj0 = 0 ;
10703 PyObject * obj1 = 0 ;
10704 PyObject * obj2 = 0 ;
10705 char * kwnames[] = {
10706 (char *) "self",(char *) "spec",(char *) "flags", NULL
10707 };
10708
10709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10711 if (!SWIG_IsOK(res1)) {
10712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10713 }
10714 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10715 {
10716 arg2 = wxString_in_helper(obj1);
10717 if (arg2 == NULL) SWIG_fail;
10718 temp2 = true;
10719 }
10720 if (obj2) {
10721 ecode3 = SWIG_AsVal_int(obj2, &val3);
10722 if (!SWIG_IsOK(ecode3)) {
10723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10724 }
10725 arg3 = static_cast< int >(val3);
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 {
10734 #if wxUSE_UNICODE
10735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10736 #else
10737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10738 #endif
10739 }
10740 {
10741 if (temp2)
10742 delete arg2;
10743 }
10744 return resultobj;
10745 fail:
10746 {
10747 if (temp2)
10748 delete arg2;
10749 }
10750 return NULL;
10751 }
10752
10753
10754 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10755 PyObject *resultobj = 0;
10756 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10757 wxString result;
10758 void *argp1 = 0 ;
10759 int res1 = 0 ;
10760 PyObject *swig_obj[1] ;
10761
10762 if (!args) SWIG_fail;
10763 swig_obj[0] = args;
10764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10767 }
10768 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 result = (arg1)->FindNext();
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 {
10776 #if wxUSE_UNICODE
10777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10778 #else
10779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10780 #endif
10781 }
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10789 PyObject *resultobj = 0;
10790 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10791 int res1 = 0 ;
10792 PyObject * obj0 = 0 ;
10793 char * kwnames[] = {
10794 (char *) "handler", NULL
10795 };
10796
10797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10798 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10799 if (!SWIG_IsOK(res1)) {
10800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10801 }
10802 {
10803 PyThreadState* __tstate = wxPyBeginAllowThreads();
10804 wxFileSystem::AddHandler(arg1);
10805 wxPyEndAllowThreads(__tstate);
10806 if (PyErr_Occurred()) SWIG_fail;
10807 }
10808 resultobj = SWIG_Py_Void();
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10816 PyObject *resultobj = 0;
10817
10818 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 wxFileSystem::CleanUpHandlers();
10822 wxPyEndAllowThreads(__tstate);
10823 if (PyErr_Occurred()) SWIG_fail;
10824 }
10825 resultobj = SWIG_Py_Void();
10826 return resultobj;
10827 fail:
10828 return NULL;
10829 }
10830
10831
10832 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10833 PyObject *resultobj = 0;
10834 wxString *arg1 = 0 ;
10835 wxString result;
10836 bool temp1 = false ;
10837 PyObject * obj0 = 0 ;
10838 char * kwnames[] = {
10839 (char *) "filename", NULL
10840 };
10841
10842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10843 {
10844 arg1 = wxString_in_helper(obj0);
10845 if (arg1 == NULL) SWIG_fail;
10846 temp1 = true;
10847 }
10848 {
10849 PyThreadState* __tstate = wxPyBeginAllowThreads();
10850 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10851 wxPyEndAllowThreads(__tstate);
10852 if (PyErr_Occurred()) SWIG_fail;
10853 }
10854 {
10855 #if wxUSE_UNICODE
10856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10857 #else
10858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10859 #endif
10860 }
10861 {
10862 if (temp1)
10863 delete arg1;
10864 }
10865 return resultobj;
10866 fail:
10867 {
10868 if (temp1)
10869 delete arg1;
10870 }
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = 0;
10877 wxString *arg1 = 0 ;
10878 wxString result;
10879 bool temp1 = false ;
10880 PyObject * obj0 = 0 ;
10881 char * kwnames[] = {
10882 (char *) "url", NULL
10883 };
10884
10885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10886 {
10887 arg1 = wxString_in_helper(obj0);
10888 if (arg1 == NULL) SWIG_fail;
10889 temp1 = true;
10890 }
10891 {
10892 PyThreadState* __tstate = wxPyBeginAllowThreads();
10893 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 {
10898 #if wxUSE_UNICODE
10899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10900 #else
10901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10902 #endif
10903 }
10904 {
10905 if (temp1)
10906 delete arg1;
10907 }
10908 return resultobj;
10909 fail:
10910 {
10911 if (temp1)
10912 delete arg1;
10913 }
10914 return NULL;
10915 }
10916
10917
10918 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10919 PyObject *obj;
10920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10921 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10922 return SWIG_Py_Void();
10923 }
10924
10925 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10926 return SWIG_Python_InitShadowInstance(args);
10927 }
10928
10929 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10930 PyObject *resultobj = 0;
10931 wxInternetFSHandler *result = 0 ;
10932
10933 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10950 wxString *arg2 = 0 ;
10951 bool result;
10952 void *argp1 = 0 ;
10953 int res1 = 0 ;
10954 bool temp2 = false ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 char * kwnames[] = {
10958 (char *) "self",(char *) "location", NULL
10959 };
10960
10961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10963 if (!SWIG_IsOK(res1)) {
10964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10965 }
10966 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10967 {
10968 arg2 = wxString_in_helper(obj1);
10969 if (arg2 == NULL) SWIG_fail;
10970 temp2 = true;
10971 }
10972 {
10973 PyThreadState* __tstate = wxPyBeginAllowThreads();
10974 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 {
10979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10980 }
10981 {
10982 if (temp2)
10983 delete arg2;
10984 }
10985 return resultobj;
10986 fail:
10987 {
10988 if (temp2)
10989 delete arg2;
10990 }
10991 return NULL;
10992 }
10993
10994
10995 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10996 PyObject *resultobj = 0;
10997 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10998 wxFileSystem *arg2 = 0 ;
10999 wxString *arg3 = 0 ;
11000 wxFSFile *result = 0 ;
11001 void *argp1 = 0 ;
11002 int res1 = 0 ;
11003 void *argp2 = 0 ;
11004 int res2 = 0 ;
11005 bool temp3 = false ;
11006 PyObject * obj0 = 0 ;
11007 PyObject * obj1 = 0 ;
11008 PyObject * obj2 = 0 ;
11009 char * kwnames[] = {
11010 (char *) "self",(char *) "fs",(char *) "location", NULL
11011 };
11012
11013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11015 if (!SWIG_IsOK(res1)) {
11016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11017 }
11018 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11019 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11020 if (!SWIG_IsOK(res2)) {
11021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11022 }
11023 if (!argp2) {
11024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11025 }
11026 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11027 {
11028 arg3 = wxString_in_helper(obj2);
11029 if (arg3 == NULL) SWIG_fail;
11030 temp3 = true;
11031 }
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11035 wxPyEndAllowThreads(__tstate);
11036 if (PyErr_Occurred()) SWIG_fail;
11037 }
11038 {
11039 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11040 }
11041 {
11042 if (temp3)
11043 delete arg3;
11044 }
11045 return resultobj;
11046 fail:
11047 {
11048 if (temp3)
11049 delete arg3;
11050 }
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 PyObject *obj;
11057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11058 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11059 return SWIG_Py_Void();
11060 }
11061
11062 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11063 return SWIG_Python_InitShadowInstance(args);
11064 }
11065
11066 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11067 PyObject *resultobj = 0;
11068 wxZipFSHandler *result = 0 ;
11069
11070 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11071 {
11072 PyThreadState* __tstate = wxPyBeginAllowThreads();
11073 result = (wxZipFSHandler *)new wxZipFSHandler();
11074 wxPyEndAllowThreads(__tstate);
11075 if (PyErr_Occurred()) SWIG_fail;
11076 }
11077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11078 return resultobj;
11079 fail:
11080 return NULL;
11081 }
11082
11083
11084 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj = 0;
11086 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11087 wxString *arg2 = 0 ;
11088 bool result;
11089 void *argp1 = 0 ;
11090 int res1 = 0 ;
11091 bool temp2 = false ;
11092 PyObject * obj0 = 0 ;
11093 PyObject * obj1 = 0 ;
11094 char * kwnames[] = {
11095 (char *) "self",(char *) "location", NULL
11096 };
11097
11098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11100 if (!SWIG_IsOK(res1)) {
11101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11102 }
11103 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11104 {
11105 arg2 = wxString_in_helper(obj1);
11106 if (arg2 == NULL) SWIG_fail;
11107 temp2 = true;
11108 }
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 {
11116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11117 }
11118 {
11119 if (temp2)
11120 delete arg2;
11121 }
11122 return resultobj;
11123 fail:
11124 {
11125 if (temp2)
11126 delete arg2;
11127 }
11128 return NULL;
11129 }
11130
11131
11132 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11133 PyObject *resultobj = 0;
11134 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11135 wxFileSystem *arg2 = 0 ;
11136 wxString *arg3 = 0 ;
11137 wxFSFile *result = 0 ;
11138 void *argp1 = 0 ;
11139 int res1 = 0 ;
11140 void *argp2 = 0 ;
11141 int res2 = 0 ;
11142 bool temp3 = false ;
11143 PyObject * obj0 = 0 ;
11144 PyObject * obj1 = 0 ;
11145 PyObject * obj2 = 0 ;
11146 char * kwnames[] = {
11147 (char *) "self",(char *) "fs",(char *) "location", NULL
11148 };
11149
11150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11152 if (!SWIG_IsOK(res1)) {
11153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11154 }
11155 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11157 if (!SWIG_IsOK(res2)) {
11158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11159 }
11160 if (!argp2) {
11161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11162 }
11163 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11164 {
11165 arg3 = wxString_in_helper(obj2);
11166 if (arg3 == NULL) SWIG_fail;
11167 temp3 = true;
11168 }
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 {
11176 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11177 }
11178 {
11179 if (temp3)
11180 delete arg3;
11181 }
11182 return resultobj;
11183 fail:
11184 {
11185 if (temp3)
11186 delete arg3;
11187 }
11188 return NULL;
11189 }
11190
11191
11192 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj = 0;
11194 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11195 wxString *arg2 = 0 ;
11196 int arg3 = (int) 0 ;
11197 wxString result;
11198 void *argp1 = 0 ;
11199 int res1 = 0 ;
11200 bool temp2 = false ;
11201 int val3 ;
11202 int ecode3 = 0 ;
11203 PyObject * obj0 = 0 ;
11204 PyObject * obj1 = 0 ;
11205 PyObject * obj2 = 0 ;
11206 char * kwnames[] = {
11207 (char *) "self",(char *) "spec",(char *) "flags", NULL
11208 };
11209
11210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11212 if (!SWIG_IsOK(res1)) {
11213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11214 }
11215 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11216 {
11217 arg2 = wxString_in_helper(obj1);
11218 if (arg2 == NULL) SWIG_fail;
11219 temp2 = true;
11220 }
11221 if (obj2) {
11222 ecode3 = SWIG_AsVal_int(obj2, &val3);
11223 if (!SWIG_IsOK(ecode3)) {
11224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11225 }
11226 arg3 = static_cast< int >(val3);
11227 }
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 {
11235 #if wxUSE_UNICODE
11236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11237 #else
11238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11239 #endif
11240 }
11241 {
11242 if (temp2)
11243 delete arg2;
11244 }
11245 return resultobj;
11246 fail:
11247 {
11248 if (temp2)
11249 delete arg2;
11250 }
11251 return NULL;
11252 }
11253
11254
11255 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11256 PyObject *resultobj = 0;
11257 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11258 wxString result;
11259 void *argp1 = 0 ;
11260 int res1 = 0 ;
11261 PyObject *swig_obj[1] ;
11262
11263 if (!args) SWIG_fail;
11264 swig_obj[0] = args;
11265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11266 if (!SWIG_IsOK(res1)) {
11267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11268 }
11269 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11270 {
11271 PyThreadState* __tstate = wxPyBeginAllowThreads();
11272 result = (arg1)->FindNext();
11273 wxPyEndAllowThreads(__tstate);
11274 if (PyErr_Occurred()) SWIG_fail;
11275 }
11276 {
11277 #if wxUSE_UNICODE
11278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11279 #else
11280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11281 #endif
11282 }
11283 return resultobj;
11284 fail:
11285 return NULL;
11286 }
11287
11288
11289 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11290 PyObject *obj;
11291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11292 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11293 return SWIG_Py_Void();
11294 }
11295
11296 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11297 return SWIG_Python_InitShadowInstance(args);
11298 }
11299
11300 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11301 PyObject *resultobj = 0;
11302 wxString *arg1 = 0 ;
11303 wxImage *arg2 = 0 ;
11304 long arg3 ;
11305 bool temp1 = false ;
11306 void *argp2 = 0 ;
11307 int res2 = 0 ;
11308 long val3 ;
11309 int ecode3 = 0 ;
11310 PyObject * obj0 = 0 ;
11311 PyObject * obj1 = 0 ;
11312 PyObject * obj2 = 0 ;
11313 char * kwnames[] = {
11314 (char *) "filename",(char *) "image",(char *) "type", NULL
11315 };
11316
11317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11318 {
11319 arg1 = wxString_in_helper(obj0);
11320 if (arg1 == NULL) SWIG_fail;
11321 temp1 = true;
11322 }
11323 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11324 if (!SWIG_IsOK(res2)) {
11325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11326 }
11327 if (!argp2) {
11328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11329 }
11330 arg2 = reinterpret_cast< wxImage * >(argp2);
11331 ecode3 = SWIG_AsVal_long(obj2, &val3);
11332 if (!SWIG_IsOK(ecode3)) {
11333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11334 }
11335 arg3 = static_cast< long >(val3);
11336 {
11337 PyThreadState* __tstate = wxPyBeginAllowThreads();
11338 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11339 wxPyEndAllowThreads(__tstate);
11340 if (PyErr_Occurred()) SWIG_fail;
11341 }
11342 resultobj = SWIG_Py_Void();
11343 {
11344 if (temp1)
11345 delete arg1;
11346 }
11347 return resultobj;
11348 fail:
11349 {
11350 if (temp1)
11351 delete arg1;
11352 }
11353 return NULL;
11354 }
11355
11356
11357 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj = 0;
11359 wxString *arg1 = 0 ;
11360 wxBitmap *arg2 = 0 ;
11361 long arg3 ;
11362 bool temp1 = false ;
11363 void *argp2 = 0 ;
11364 int res2 = 0 ;
11365 long val3 ;
11366 int ecode3 = 0 ;
11367 PyObject * obj0 = 0 ;
11368 PyObject * obj1 = 0 ;
11369 PyObject * obj2 = 0 ;
11370 char * kwnames[] = {
11371 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11372 };
11373
11374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11375 {
11376 arg1 = wxString_in_helper(obj0);
11377 if (arg1 == NULL) SWIG_fail;
11378 temp1 = true;
11379 }
11380 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11381 if (!SWIG_IsOK(res2)) {
11382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11383 }
11384 if (!argp2) {
11385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11386 }
11387 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11388 ecode3 = SWIG_AsVal_long(obj2, &val3);
11389 if (!SWIG_IsOK(ecode3)) {
11390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11391 }
11392 arg3 = static_cast< long >(val3);
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11396 wxPyEndAllowThreads(__tstate);
11397 if (PyErr_Occurred()) SWIG_fail;
11398 }
11399 resultobj = SWIG_Py_Void();
11400 {
11401 if (temp1)
11402 delete arg1;
11403 }
11404 return resultobj;
11405 fail:
11406 {
11407 if (temp1)
11408 delete arg1;
11409 }
11410 return NULL;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11415 PyObject *resultobj = 0;
11416 wxString *arg1 = 0 ;
11417 PyObject *arg2 = (PyObject *) 0 ;
11418 bool temp1 = false ;
11419 PyObject * obj0 = 0 ;
11420 PyObject * obj1 = 0 ;
11421 char * kwnames[] = {
11422 (char *) "filename",(char *) "data", NULL
11423 };
11424
11425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11426 {
11427 arg1 = wxString_in_helper(obj0);
11428 if (arg1 == NULL) SWIG_fail;
11429 temp1 = true;
11430 }
11431 arg2 = obj1;
11432 {
11433 PyThreadState* __tstate = wxPyBeginAllowThreads();
11434 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11435 wxPyEndAllowThreads(__tstate);
11436 if (PyErr_Occurred()) SWIG_fail;
11437 }
11438 resultobj = SWIG_Py_Void();
11439 {
11440 if (temp1)
11441 delete arg1;
11442 }
11443 return resultobj;
11444 fail:
11445 {
11446 if (temp1)
11447 delete arg1;
11448 }
11449 return NULL;
11450 }
11451
11452
11453 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 PyObject *resultobj = 0;
11455 wxMemoryFSHandler *result = 0 ;
11456
11457 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11458 {
11459 PyThreadState* __tstate = wxPyBeginAllowThreads();
11460 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11465 return resultobj;
11466 fail:
11467 return NULL;
11468 }
11469
11470
11471 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj = 0;
11473 wxString *arg1 = 0 ;
11474 bool temp1 = false ;
11475 PyObject * obj0 = 0 ;
11476 char * kwnames[] = {
11477 (char *) "filename", NULL
11478 };
11479
11480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11481 {
11482 arg1 = wxString_in_helper(obj0);
11483 if (arg1 == NULL) SWIG_fail;
11484 temp1 = true;
11485 }
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = SWIG_Py_Void();
11493 {
11494 if (temp1)
11495 delete arg1;
11496 }
11497 return resultobj;
11498 fail:
11499 {
11500 if (temp1)
11501 delete arg1;
11502 }
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = 0;
11509 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11510 wxString *arg2 = 0 ;
11511 bool result;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 bool temp2 = false ;
11515 PyObject * obj0 = 0 ;
11516 PyObject * obj1 = 0 ;
11517 char * kwnames[] = {
11518 (char *) "self",(char *) "location", NULL
11519 };
11520
11521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11523 if (!SWIG_IsOK(res1)) {
11524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11525 }
11526 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11527 {
11528 arg2 = wxString_in_helper(obj1);
11529 if (arg2 == NULL) SWIG_fail;
11530 temp2 = true;
11531 }
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 {
11539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11540 }
11541 {
11542 if (temp2)
11543 delete arg2;
11544 }
11545 return resultobj;
11546 fail:
11547 {
11548 if (temp2)
11549 delete arg2;
11550 }
11551 return NULL;
11552 }
11553
11554
11555 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj = 0;
11557 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11558 wxFileSystem *arg2 = 0 ;
11559 wxString *arg3 = 0 ;
11560 wxFSFile *result = 0 ;
11561 void *argp1 = 0 ;
11562 int res1 = 0 ;
11563 void *argp2 = 0 ;
11564 int res2 = 0 ;
11565 bool temp3 = false ;
11566 PyObject * obj0 = 0 ;
11567 PyObject * obj1 = 0 ;
11568 PyObject * obj2 = 0 ;
11569 char * kwnames[] = {
11570 (char *) "self",(char *) "fs",(char *) "location", NULL
11571 };
11572
11573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11575 if (!SWIG_IsOK(res1)) {
11576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11577 }
11578 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11580 if (!SWIG_IsOK(res2)) {
11581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11582 }
11583 if (!argp2) {
11584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11585 }
11586 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11587 {
11588 arg3 = wxString_in_helper(obj2);
11589 if (arg3 == NULL) SWIG_fail;
11590 temp3 = true;
11591 }
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 {
11599 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11600 }
11601 {
11602 if (temp3)
11603 delete arg3;
11604 }
11605 return resultobj;
11606 fail:
11607 {
11608 if (temp3)
11609 delete arg3;
11610 }
11611 return NULL;
11612 }
11613
11614
11615 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11616 PyObject *resultobj = 0;
11617 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11618 wxString *arg2 = 0 ;
11619 int arg3 = (int) 0 ;
11620 wxString result;
11621 void *argp1 = 0 ;
11622 int res1 = 0 ;
11623 bool temp2 = false ;
11624 int val3 ;
11625 int ecode3 = 0 ;
11626 PyObject * obj0 = 0 ;
11627 PyObject * obj1 = 0 ;
11628 PyObject * obj2 = 0 ;
11629 char * kwnames[] = {
11630 (char *) "self",(char *) "spec",(char *) "flags", NULL
11631 };
11632
11633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11635 if (!SWIG_IsOK(res1)) {
11636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11637 }
11638 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11639 {
11640 arg2 = wxString_in_helper(obj1);
11641 if (arg2 == NULL) SWIG_fail;
11642 temp2 = true;
11643 }
11644 if (obj2) {
11645 ecode3 = SWIG_AsVal_int(obj2, &val3);
11646 if (!SWIG_IsOK(ecode3)) {
11647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11648 }
11649 arg3 = static_cast< int >(val3);
11650 }
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 {
11658 #if wxUSE_UNICODE
11659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11660 #else
11661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11662 #endif
11663 }
11664 {
11665 if (temp2)
11666 delete arg2;
11667 }
11668 return resultobj;
11669 fail:
11670 {
11671 if (temp2)
11672 delete arg2;
11673 }
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 PyObject *resultobj = 0;
11680 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11681 wxString result;
11682 void *argp1 = 0 ;
11683 int res1 = 0 ;
11684 PyObject *swig_obj[1] ;
11685
11686 if (!args) SWIG_fail;
11687 swig_obj[0] = args;
11688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11689 if (!SWIG_IsOK(res1)) {
11690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11691 }
11692 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 result = (arg1)->FindNext();
11696 wxPyEndAllowThreads(__tstate);
11697 if (PyErr_Occurred()) SWIG_fail;
11698 }
11699 {
11700 #if wxUSE_UNICODE
11701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11702 #else
11703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11704 #endif
11705 }
11706 return resultobj;
11707 fail:
11708 return NULL;
11709 }
11710
11711
11712 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11713 PyObject *obj;
11714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11715 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11716 return SWIG_Py_Void();
11717 }
11718
11719 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11720 return SWIG_Python_InitShadowInstance(args);
11721 }
11722
11723 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 PyObject *resultobj = 0;
11725 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11726 wxString result;
11727 void *argp1 = 0 ;
11728 int res1 = 0 ;
11729 PyObject *swig_obj[1] ;
11730
11731 if (!args) SWIG_fail;
11732 swig_obj[0] = args;
11733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11734 if (!SWIG_IsOK(res1)) {
11735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11736 }
11737 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11738 {
11739 PyThreadState* __tstate = wxPyBeginAllowThreads();
11740 result = (arg1)->GetName();
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 {
11745 #if wxUSE_UNICODE
11746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11747 #else
11748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11749 #endif
11750 }
11751 return resultobj;
11752 fail:
11753 return NULL;
11754 }
11755
11756
11757 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11758 PyObject *resultobj = 0;
11759 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11760 wxString result;
11761 void *argp1 = 0 ;
11762 int res1 = 0 ;
11763 PyObject *swig_obj[1] ;
11764
11765 if (!args) SWIG_fail;
11766 swig_obj[0] = args;
11767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11768 if (!SWIG_IsOK(res1)) {
11769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11770 }
11771 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11772 {
11773 PyThreadState* __tstate = wxPyBeginAllowThreads();
11774 result = (arg1)->GetExtension();
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 {
11779 #if wxUSE_UNICODE
11780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11781 #else
11782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11783 #endif
11784 }
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792 PyObject *resultobj = 0;
11793 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11794 long result;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 PyObject *swig_obj[1] ;
11798
11799 if (!args) SWIG_fail;
11800 swig_obj[0] = args;
11801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11802 if (!SWIG_IsOK(res1)) {
11803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11804 }
11805 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (long)(arg1)->GetType();
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_From_long(static_cast< long >(result));
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 PyObject *resultobj = 0;
11821 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11822 wxString result;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 PyObject *swig_obj[1] ;
11826
11827 if (!args) SWIG_fail;
11828 swig_obj[0] = args;
11829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11832 }
11833 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (arg1)->GetMimeType();
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 #if wxUSE_UNICODE
11842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11843 #else
11844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11845 #endif
11846 }
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj = 0;
11855 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11856 wxString *arg2 = 0 ;
11857 bool result;
11858 void *argp1 = 0 ;
11859 int res1 = 0 ;
11860 bool temp2 = false ;
11861 PyObject * obj0 = 0 ;
11862 PyObject * obj1 = 0 ;
11863 char * kwnames[] = {
11864 (char *) "self",(char *) "name", NULL
11865 };
11866
11867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11869 if (!SWIG_IsOK(res1)) {
11870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11871 }
11872 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11873 {
11874 arg2 = wxString_in_helper(obj1);
11875 if (arg2 == NULL) SWIG_fail;
11876 temp2 = true;
11877 }
11878 {
11879 PyThreadState* __tstate = wxPyBeginAllowThreads();
11880 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11881 wxPyEndAllowThreads(__tstate);
11882 if (PyErr_Occurred()) SWIG_fail;
11883 }
11884 {
11885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11886 }
11887 {
11888 if (temp2)
11889 delete arg2;
11890 }
11891 return resultobj;
11892 fail:
11893 {
11894 if (temp2)
11895 delete arg2;
11896 }
11897 return NULL;
11898 }
11899
11900
11901 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11902 PyObject *resultobj = 0;
11903 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11904 wxInputStream *arg2 = 0 ;
11905 bool result;
11906 void *argp1 = 0 ;
11907 int res1 = 0 ;
11908 wxPyInputStream *temp2 ;
11909 bool created2 ;
11910 PyObject * obj0 = 0 ;
11911 PyObject * obj1 = 0 ;
11912 char * kwnames[] = {
11913 (char *) "self",(char *) "stream", NULL
11914 };
11915
11916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11918 if (!SWIG_IsOK(res1)) {
11919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11920 }
11921 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11922 {
11923 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11924 arg2 = temp2->m_wxis;
11925 created2 = false;
11926 } else {
11927 PyErr_Clear(); // clear the failure of the wxPyConvert above
11928 arg2 = wxPyCBInputStream_create(obj1, false);
11929 if (arg2 == NULL) {
11930 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11931 SWIG_fail;
11932 }
11933 created2 = true;
11934 }
11935 }
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->CanRead(*arg2);
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 {
11946 if (created2) delete arg2;
11947 }
11948 return resultobj;
11949 fail:
11950 {
11951 if (created2) delete arg2;
11952 }
11953 return NULL;
11954 }
11955
11956
11957 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11958 PyObject *resultobj = 0;
11959 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11960 wxString *arg2 = 0 ;
11961 void *argp1 = 0 ;
11962 int res1 = 0 ;
11963 bool temp2 = false ;
11964 PyObject * obj0 = 0 ;
11965 PyObject * obj1 = 0 ;
11966 char * kwnames[] = {
11967 (char *) "self",(char *) "name", NULL
11968 };
11969
11970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11972 if (!SWIG_IsOK(res1)) {
11973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11974 }
11975 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11976 {
11977 arg2 = wxString_in_helper(obj1);
11978 if (arg2 == NULL) SWIG_fail;
11979 temp2 = true;
11980 }
11981 {
11982 PyThreadState* __tstate = wxPyBeginAllowThreads();
11983 (arg1)->SetName((wxString const &)*arg2);
11984 wxPyEndAllowThreads(__tstate);
11985 if (PyErr_Occurred()) SWIG_fail;
11986 }
11987 resultobj = SWIG_Py_Void();
11988 {
11989 if (temp2)
11990 delete arg2;
11991 }
11992 return resultobj;
11993 fail:
11994 {
11995 if (temp2)
11996 delete arg2;
11997 }
11998 return NULL;
11999 }
12000
12001
12002 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12003 PyObject *resultobj = 0;
12004 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12005 wxString *arg2 = 0 ;
12006 void *argp1 = 0 ;
12007 int res1 = 0 ;
12008 bool temp2 = false ;
12009 PyObject * obj0 = 0 ;
12010 PyObject * obj1 = 0 ;
12011 char * kwnames[] = {
12012 (char *) "self",(char *) "extension", NULL
12013 };
12014
12015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12017 if (!SWIG_IsOK(res1)) {
12018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12019 }
12020 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12021 {
12022 arg2 = wxString_in_helper(obj1);
12023 if (arg2 == NULL) SWIG_fail;
12024 temp2 = true;
12025 }
12026 {
12027 PyThreadState* __tstate = wxPyBeginAllowThreads();
12028 (arg1)->SetExtension((wxString const &)*arg2);
12029 wxPyEndAllowThreads(__tstate);
12030 if (PyErr_Occurred()) SWIG_fail;
12031 }
12032 resultobj = SWIG_Py_Void();
12033 {
12034 if (temp2)
12035 delete arg2;
12036 }
12037 return resultobj;
12038 fail:
12039 {
12040 if (temp2)
12041 delete arg2;
12042 }
12043 return NULL;
12044 }
12045
12046
12047 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj = 0;
12049 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12050 long arg2 ;
12051 void *argp1 = 0 ;
12052 int res1 = 0 ;
12053 long val2 ;
12054 int ecode2 = 0 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char * kwnames[] = {
12058 (char *) "self",(char *) "type", NULL
12059 };
12060
12061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12063 if (!SWIG_IsOK(res1)) {
12064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12065 }
12066 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12067 ecode2 = SWIG_AsVal_long(obj1, &val2);
12068 if (!SWIG_IsOK(ecode2)) {
12069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12070 }
12071 arg2 = static_cast< long >(val2);
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 (arg1)->SetType(arg2);
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 resultobj = SWIG_Py_Void();
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12086 PyObject *resultobj = 0;
12087 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12088 wxString *arg2 = 0 ;
12089 void *argp1 = 0 ;
12090 int res1 = 0 ;
12091 bool temp2 = false ;
12092 PyObject * obj0 = 0 ;
12093 PyObject * obj1 = 0 ;
12094 char * kwnames[] = {
12095 (char *) "self",(char *) "mimetype", NULL
12096 };
12097
12098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12100 if (!SWIG_IsOK(res1)) {
12101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12102 }
12103 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12104 {
12105 arg2 = wxString_in_helper(obj1);
12106 if (arg2 == NULL) SWIG_fail;
12107 temp2 = true;
12108 }
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 (arg1)->SetMimeType((wxString const &)*arg2);
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 resultobj = SWIG_Py_Void();
12116 {
12117 if (temp2)
12118 delete arg2;
12119 }
12120 return resultobj;
12121 fail:
12122 {
12123 if (temp2)
12124 delete arg2;
12125 }
12126 return NULL;
12127 }
12128
12129
12130 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12131 PyObject *obj;
12132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12133 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12134 return SWIG_Py_Void();
12135 }
12136
12137 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12138 PyObject *resultobj = 0;
12139 wxPyImageHandler *result = 0 ;
12140
12141 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 result = (wxPyImageHandler *)new wxPyImageHandler();
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12156 PyObject *resultobj = 0;
12157 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12158 PyObject *arg2 = (PyObject *) 0 ;
12159 void *argp1 = 0 ;
12160 int res1 = 0 ;
12161 PyObject * obj0 = 0 ;
12162 PyObject * obj1 = 0 ;
12163 char * kwnames[] = {
12164 (char *) "self",(char *) "self", NULL
12165 };
12166
12167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12169 if (!SWIG_IsOK(res1)) {
12170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12171 }
12172 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12173 arg2 = obj1;
12174 {
12175 PyThreadState* __tstate = wxPyBeginAllowThreads();
12176 (arg1)->_SetSelf(arg2);
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 resultobj = SWIG_Py_Void();
12181 return resultobj;
12182 fail:
12183 return NULL;
12184 }
12185
12186
12187 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12188 PyObject *obj;
12189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12190 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12191 return SWIG_Py_Void();
12192 }
12193
12194 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12195 return SWIG_Python_InitShadowInstance(args);
12196 }
12197
12198 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12199 PyObject *resultobj = 0;
12200 wxImageHistogram *result = 0 ;
12201
12202 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (wxImageHistogram *)new wxImageHistogram();
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj = 0;
12218 byte arg1 ;
12219 byte arg2 ;
12220 byte arg3 ;
12221 unsigned long result;
12222 unsigned char val1 ;
12223 int ecode1 = 0 ;
12224 unsigned char val2 ;
12225 int ecode2 = 0 ;
12226 unsigned char val3 ;
12227 int ecode3 = 0 ;
12228 PyObject * obj0 = 0 ;
12229 PyObject * obj1 = 0 ;
12230 PyObject * obj2 = 0 ;
12231 char * kwnames[] = {
12232 (char *) "r",(char *) "g",(char *) "b", NULL
12233 };
12234
12235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12236 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12237 if (!SWIG_IsOK(ecode1)) {
12238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12239 }
12240 arg1 = static_cast< byte >(val1);
12241 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12242 if (!SWIG_IsOK(ecode2)) {
12243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12244 }
12245 arg2 = static_cast< byte >(val2);
12246 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12247 if (!SWIG_IsOK(ecode3)) {
12248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12249 }
12250 arg3 = static_cast< byte >(val3);
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj = 0;
12266 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12267 byte *arg2 = (byte *) 0 ;
12268 byte *arg3 = (byte *) 0 ;
12269 byte *arg4 = (byte *) 0 ;
12270 byte arg5 = (byte) 1 ;
12271 byte arg6 = (byte) 0 ;
12272 byte arg7 = (byte) 0 ;
12273 bool result;
12274 void *argp1 = 0 ;
12275 int res1 = 0 ;
12276 byte temp2 ;
12277 int res2 = SWIG_TMPOBJ ;
12278 byte temp3 ;
12279 int res3 = SWIG_TMPOBJ ;
12280 byte temp4 ;
12281 int res4 = SWIG_TMPOBJ ;
12282 unsigned char val5 ;
12283 int ecode5 = 0 ;
12284 unsigned char val6 ;
12285 int ecode6 = 0 ;
12286 unsigned char val7 ;
12287 int ecode7 = 0 ;
12288 PyObject * obj0 = 0 ;
12289 PyObject * obj1 = 0 ;
12290 PyObject * obj2 = 0 ;
12291 PyObject * obj3 = 0 ;
12292 char * kwnames[] = {
12293 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12294 };
12295
12296 arg2 = &temp2;
12297 arg3 = &temp3;
12298 arg4 = &temp4;
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12303 }
12304 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12305 if (obj1) {
12306 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12307 if (!SWIG_IsOK(ecode5)) {
12308 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12309 }
12310 arg5 = static_cast< byte >(val5);
12311 }
12312 if (obj2) {
12313 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12314 if (!SWIG_IsOK(ecode6)) {
12315 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12316 }
12317 arg6 = static_cast< byte >(val6);
12318 }
12319 if (obj3) {
12320 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12321 if (!SWIG_IsOK(ecode7)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12323 }
12324 arg7 = static_cast< byte >(val7);
12325 }
12326 {
12327 PyThreadState* __tstate = wxPyBeginAllowThreads();
12328 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 {
12333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12334 }
12335 if (SWIG_IsTmpObj(res2)) {
12336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12337 } else {
12338 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12340 }
12341 if (SWIG_IsTmpObj(res3)) {
12342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12343 } else {
12344 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12346 }
12347 if (SWIG_IsTmpObj(res4)) {
12348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12349 } else {
12350 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12352 }
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj = 0;
12361 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12362 unsigned long arg2 ;
12363 unsigned long result;
12364 void *argp1 = 0 ;
12365 int res1 = 0 ;
12366 unsigned long val2 ;
12367 int ecode2 = 0 ;
12368 PyObject * obj0 = 0 ;
12369 PyObject * obj1 = 0 ;
12370 char * kwnames[] = {
12371 (char *) "self",(char *) "key", NULL
12372 };
12373
12374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12376 if (!SWIG_IsOK(res1)) {
12377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12378 }
12379 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12380 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12381 if (!SWIG_IsOK(ecode2)) {
12382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12383 }
12384 arg2 = static_cast< unsigned long >(val2);
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12392 return resultobj;
12393 fail:
12394 return NULL;
12395 }
12396
12397
12398 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12399 PyObject *resultobj = 0;
12400 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12401 byte arg2 ;
12402 byte arg3 ;
12403 byte arg4 ;
12404 unsigned long result;
12405 void *argp1 = 0 ;
12406 int res1 = 0 ;
12407 unsigned char val2 ;
12408 int ecode2 = 0 ;
12409 unsigned char val3 ;
12410 int ecode3 = 0 ;
12411 unsigned char val4 ;
12412 int ecode4 = 0 ;
12413 PyObject * obj0 = 0 ;
12414 PyObject * obj1 = 0 ;
12415 PyObject * obj2 = 0 ;
12416 PyObject * obj3 = 0 ;
12417 char * kwnames[] = {
12418 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12419 };
12420
12421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12423 if (!SWIG_IsOK(res1)) {
12424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12425 }
12426 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12427 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12428 if (!SWIG_IsOK(ecode2)) {
12429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12430 }
12431 arg2 = static_cast< byte >(val2);
12432 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12433 if (!SWIG_IsOK(ecode3)) {
12434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12435 }
12436 arg3 = static_cast< byte >(val3);
12437 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12438 if (!SWIG_IsOK(ecode4)) {
12439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12440 }
12441 arg4 = static_cast< byte >(val4);
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12445 wxPyEndAllowThreads(__tstate);
12446 if (PyErr_Occurred()) SWIG_fail;
12447 }
12448 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12449 return resultobj;
12450 fail:
12451 return NULL;
12452 }
12453
12454
12455 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12456 PyObject *resultobj = 0;
12457 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12458 wxColour *arg2 = 0 ;
12459 unsigned long result;
12460 void *argp1 = 0 ;
12461 int res1 = 0 ;
12462 wxColour temp2 ;
12463 PyObject * obj0 = 0 ;
12464 PyObject * obj1 = 0 ;
12465 char * kwnames[] = {
12466 (char *) "self",(char *) "colour", NULL
12467 };
12468
12469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12471 if (!SWIG_IsOK(res1)) {
12472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12473 }
12474 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12475 {
12476 arg2 = &temp2;
12477 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12478 }
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12486 return resultobj;
12487 fail:
12488 return NULL;
12489 }
12490
12491
12492 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12493 PyObject *obj;
12494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12495 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12496 return SWIG_Py_Void();
12497 }
12498
12499 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12500 return SWIG_Python_InitShadowInstance(args);
12501 }
12502
12503 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12504 PyObject *resultobj = 0;
12505 byte arg1 = (byte) 0 ;
12506 byte arg2 = (byte) 0 ;
12507 byte arg3 = (byte) 0 ;
12508 wxImage_RGBValue *result = 0 ;
12509 unsigned char val1 ;
12510 int ecode1 = 0 ;
12511 unsigned char val2 ;
12512 int ecode2 = 0 ;
12513 unsigned char val3 ;
12514 int ecode3 = 0 ;
12515 PyObject * obj0 = 0 ;
12516 PyObject * obj1 = 0 ;
12517 PyObject * obj2 = 0 ;
12518 char * kwnames[] = {
12519 (char *) "r",(char *) "g",(char *) "b", NULL
12520 };
12521
12522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12523 if (obj0) {
12524 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12525 if (!SWIG_IsOK(ecode1)) {
12526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12527 }
12528 arg1 = static_cast< byte >(val1);
12529 }
12530 if (obj1) {
12531 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12532 if (!SWIG_IsOK(ecode2)) {
12533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12534 }
12535 arg2 = static_cast< byte >(val2);
12536 }
12537 if (obj2) {
12538 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12539 if (!SWIG_IsOK(ecode3)) {
12540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12541 }
12542 arg3 = static_cast< byte >(val3);
12543 }
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12551 return resultobj;
12552 fail:
12553 return NULL;
12554 }
12555
12556
12557 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12558 PyObject *resultobj = 0;
12559 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12560 byte arg2 ;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 unsigned char val2 ;
12564 int ecode2 = 0 ;
12565 PyObject *swig_obj[2] ;
12566
12567 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12569 if (!SWIG_IsOK(res1)) {
12570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12571 }
12572 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12573 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12574 if (!SWIG_IsOK(ecode2)) {
12575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12576 }
12577 arg2 = static_cast< byte >(val2);
12578 if (arg1) (arg1)->red = arg2;
12579
12580 resultobj = SWIG_Py_Void();
12581 return resultobj;
12582 fail:
12583 return NULL;
12584 }
12585
12586
12587 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12588 PyObject *resultobj = 0;
12589 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12590 byte result;
12591 void *argp1 = 0 ;
12592 int res1 = 0 ;
12593 PyObject *swig_obj[1] ;
12594
12595 if (!args) SWIG_fail;
12596 swig_obj[0] = args;
12597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12598 if (!SWIG_IsOK(res1)) {
12599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12600 }
12601 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12602 result = (byte) ((arg1)->red);
12603 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12611 PyObject *resultobj = 0;
12612 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12613 byte arg2 ;
12614 void *argp1 = 0 ;
12615 int res1 = 0 ;
12616 unsigned char val2 ;
12617 int ecode2 = 0 ;
12618 PyObject *swig_obj[2] ;
12619
12620 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12622 if (!SWIG_IsOK(res1)) {
12623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12624 }
12625 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12626 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12627 if (!SWIG_IsOK(ecode2)) {
12628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12629 }
12630 arg2 = static_cast< byte >(val2);
12631 if (arg1) (arg1)->green = arg2;
12632
12633 resultobj = SWIG_Py_Void();
12634 return resultobj;
12635 fail:
12636 return NULL;
12637 }
12638
12639
12640 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12641 PyObject *resultobj = 0;
12642 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12643 byte result;
12644 void *argp1 = 0 ;
12645 int res1 = 0 ;
12646 PyObject *swig_obj[1] ;
12647
12648 if (!args) SWIG_fail;
12649 swig_obj[0] = args;
12650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12651 if (!SWIG_IsOK(res1)) {
12652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12653 }
12654 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12655 result = (byte) ((arg1)->green);
12656 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12657 return resultobj;
12658 fail:
12659 return NULL;
12660 }
12661
12662
12663 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12664 PyObject *resultobj = 0;
12665 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12666 byte arg2 ;
12667 void *argp1 = 0 ;
12668 int res1 = 0 ;
12669 unsigned char val2 ;
12670 int ecode2 = 0 ;
12671 PyObject *swig_obj[2] ;
12672
12673 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12675 if (!SWIG_IsOK(res1)) {
12676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12677 }
12678 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12679 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12680 if (!SWIG_IsOK(ecode2)) {
12681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12682 }
12683 arg2 = static_cast< byte >(val2);
12684 if (arg1) (arg1)->blue = arg2;
12685
12686 resultobj = SWIG_Py_Void();
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12694 PyObject *resultobj = 0;
12695 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12696 byte result;
12697 void *argp1 = 0 ;
12698 int res1 = 0 ;
12699 PyObject *swig_obj[1] ;
12700
12701 if (!args) SWIG_fail;
12702 swig_obj[0] = args;
12703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12704 if (!SWIG_IsOK(res1)) {
12705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12706 }
12707 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12708 result = (byte) ((arg1)->blue);
12709 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12710 return resultobj;
12711 fail:
12712 return NULL;
12713 }
12714
12715
12716 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12717 PyObject *obj;
12718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12719 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12720 return SWIG_Py_Void();
12721 }
12722
12723 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 return SWIG_Python_InitShadowInstance(args);
12725 }
12726
12727 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12728 PyObject *resultobj = 0;
12729 double arg1 = (double) 0.0 ;
12730 double arg2 = (double) 0.0 ;
12731 double arg3 = (double) 0.0 ;
12732 wxImage_HSVValue *result = 0 ;
12733 double val1 ;
12734 int ecode1 = 0 ;
12735 double val2 ;
12736 int ecode2 = 0 ;
12737 double val3 ;
12738 int ecode3 = 0 ;
12739 PyObject * obj0 = 0 ;
12740 PyObject * obj1 = 0 ;
12741 PyObject * obj2 = 0 ;
12742 char * kwnames[] = {
12743 (char *) "h",(char *) "s",(char *) "v", NULL
12744 };
12745
12746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12747 if (obj0) {
12748 ecode1 = SWIG_AsVal_double(obj0, &val1);
12749 if (!SWIG_IsOK(ecode1)) {
12750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12751 }
12752 arg1 = static_cast< double >(val1);
12753 }
12754 if (obj1) {
12755 ecode2 = SWIG_AsVal_double(obj1, &val2);
12756 if (!SWIG_IsOK(ecode2)) {
12757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12758 }
12759 arg2 = static_cast< double >(val2);
12760 }
12761 if (obj2) {
12762 ecode3 = SWIG_AsVal_double(obj2, &val3);
12763 if (!SWIG_IsOK(ecode3)) {
12764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12765 }
12766 arg3 = static_cast< double >(val3);
12767 }
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12782 PyObject *resultobj = 0;
12783 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12784 double arg2 ;
12785 void *argp1 = 0 ;
12786 int res1 = 0 ;
12787 double val2 ;
12788 int ecode2 = 0 ;
12789 PyObject *swig_obj[2] ;
12790
12791 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12793 if (!SWIG_IsOK(res1)) {
12794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12795 }
12796 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12797 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12798 if (!SWIG_IsOK(ecode2)) {
12799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12800 }
12801 arg2 = static_cast< double >(val2);
12802 if (arg1) (arg1)->hue = arg2;
12803
12804 resultobj = SWIG_Py_Void();
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12812 PyObject *resultobj = 0;
12813 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12814 double result;
12815 void *argp1 = 0 ;
12816 int res1 = 0 ;
12817 PyObject *swig_obj[1] ;
12818
12819 if (!args) SWIG_fail;
12820 swig_obj[0] = args;
12821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12822 if (!SWIG_IsOK(res1)) {
12823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12824 }
12825 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12826 result = (double) ((arg1)->hue);
12827 resultobj = SWIG_From_double(static_cast< double >(result));
12828 return resultobj;
12829 fail:
12830 return NULL;
12831 }
12832
12833
12834 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835 PyObject *resultobj = 0;
12836 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12837 double arg2 ;
12838 void *argp1 = 0 ;
12839 int res1 = 0 ;
12840 double val2 ;
12841 int ecode2 = 0 ;
12842 PyObject *swig_obj[2] ;
12843
12844 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12846 if (!SWIG_IsOK(res1)) {
12847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12848 }
12849 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12850 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12851 if (!SWIG_IsOK(ecode2)) {
12852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12853 }
12854 arg2 = static_cast< double >(val2);
12855 if (arg1) (arg1)->saturation = arg2;
12856
12857 resultobj = SWIG_Py_Void();
12858 return resultobj;
12859 fail:
12860 return NULL;
12861 }
12862
12863
12864 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12865 PyObject *resultobj = 0;
12866 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12867 double result;
12868 void *argp1 = 0 ;
12869 int res1 = 0 ;
12870 PyObject *swig_obj[1] ;
12871
12872 if (!args) SWIG_fail;
12873 swig_obj[0] = args;
12874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12875 if (!SWIG_IsOK(res1)) {
12876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12877 }
12878 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12879 result = (double) ((arg1)->saturation);
12880 resultobj = SWIG_From_double(static_cast< double >(result));
12881 return resultobj;
12882 fail:
12883 return NULL;
12884 }
12885
12886
12887 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12888 PyObject *resultobj = 0;
12889 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12890 double arg2 ;
12891 void *argp1 = 0 ;
12892 int res1 = 0 ;
12893 double val2 ;
12894 int ecode2 = 0 ;
12895 PyObject *swig_obj[2] ;
12896
12897 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12899 if (!SWIG_IsOK(res1)) {
12900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12901 }
12902 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12903 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12904 if (!SWIG_IsOK(ecode2)) {
12905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12906 }
12907 arg2 = static_cast< double >(val2);
12908 if (arg1) (arg1)->value = arg2;
12909
12910 resultobj = SWIG_Py_Void();
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12918 PyObject *resultobj = 0;
12919 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12920 double result;
12921 void *argp1 = 0 ;
12922 int res1 = 0 ;
12923 PyObject *swig_obj[1] ;
12924
12925 if (!args) SWIG_fail;
12926 swig_obj[0] = args;
12927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12928 if (!SWIG_IsOK(res1)) {
12929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12930 }
12931 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12932 result = (double) ((arg1)->value);
12933 resultobj = SWIG_From_double(static_cast< double >(result));
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941 PyObject *obj;
12942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12943 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12944 return SWIG_Py_Void();
12945 }
12946
12947 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12948 return SWIG_Python_InitShadowInstance(args);
12949 }
12950
12951 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12952 PyObject *resultobj = 0;
12953 wxString *arg1 = 0 ;
12954 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12955 int arg3 = (int) -1 ;
12956 wxImage *result = 0 ;
12957 bool temp1 = false ;
12958 long val2 ;
12959 int ecode2 = 0 ;
12960 int val3 ;
12961 int ecode3 = 0 ;
12962 PyObject * obj0 = 0 ;
12963 PyObject * obj1 = 0 ;
12964 PyObject * obj2 = 0 ;
12965 char * kwnames[] = {
12966 (char *) "name",(char *) "type",(char *) "index", NULL
12967 };
12968
12969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12970 {
12971 arg1 = wxString_in_helper(obj0);
12972 if (arg1 == NULL) SWIG_fail;
12973 temp1 = true;
12974 }
12975 if (obj1) {
12976 ecode2 = SWIG_AsVal_long(obj1, &val2);
12977 if (!SWIG_IsOK(ecode2)) {
12978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12979 }
12980 arg2 = static_cast< long >(val2);
12981 }
12982 if (obj2) {
12983 ecode3 = SWIG_AsVal_int(obj2, &val3);
12984 if (!SWIG_IsOK(ecode3)) {
12985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12986 }
12987 arg3 = static_cast< int >(val3);
12988 }
12989 {
12990 PyThreadState* __tstate = wxPyBeginAllowThreads();
12991 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12992 wxPyEndAllowThreads(__tstate);
12993 if (PyErr_Occurred()) SWIG_fail;
12994 }
12995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12996 {
12997 if (temp1)
12998 delete arg1;
12999 }
13000 return resultobj;
13001 fail:
13002 {
13003 if (temp1)
13004 delete arg1;
13005 }
13006 return NULL;
13007 }
13008
13009
13010 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13011 PyObject *resultobj = 0;
13012 wxImage *arg1 = (wxImage *) 0 ;
13013 void *argp1 = 0 ;
13014 int res1 = 0 ;
13015 PyObject *swig_obj[1] ;
13016
13017 if (!args) SWIG_fail;
13018 swig_obj[0] = args;
13019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13020 if (!SWIG_IsOK(res1)) {
13021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13022 }
13023 arg1 = reinterpret_cast< wxImage * >(argp1);
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 delete arg1;
13027
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 resultobj = SWIG_Py_Void();
13032 return resultobj;
13033 fail:
13034 return NULL;
13035 }
13036
13037
13038 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13039 PyObject *resultobj = 0;
13040 wxString *arg1 = 0 ;
13041 wxString *arg2 = 0 ;
13042 int arg3 = (int) -1 ;
13043 wxImage *result = 0 ;
13044 bool temp1 = false ;
13045 bool temp2 = false ;
13046 int val3 ;
13047 int ecode3 = 0 ;
13048 PyObject * obj0 = 0 ;
13049 PyObject * obj1 = 0 ;
13050 PyObject * obj2 = 0 ;
13051 char * kwnames[] = {
13052 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13053 };
13054
13055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13056 {
13057 arg1 = wxString_in_helper(obj0);
13058 if (arg1 == NULL) SWIG_fail;
13059 temp1 = true;
13060 }
13061 {
13062 arg2 = wxString_in_helper(obj1);
13063 if (arg2 == NULL) SWIG_fail;
13064 temp2 = true;
13065 }
13066 if (obj2) {
13067 ecode3 = SWIG_AsVal_int(obj2, &val3);
13068 if (!SWIG_IsOK(ecode3)) {
13069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13070 }
13071 arg3 = static_cast< int >(val3);
13072 }
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13076 wxPyEndAllowThreads(__tstate);
13077 if (PyErr_Occurred()) SWIG_fail;
13078 }
13079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13080 {
13081 if (temp1)
13082 delete arg1;
13083 }
13084 {
13085 if (temp2)
13086 delete arg2;
13087 }
13088 return resultobj;
13089 fail:
13090 {
13091 if (temp1)
13092 delete arg1;
13093 }
13094 {
13095 if (temp2)
13096 delete arg2;
13097 }
13098 return NULL;
13099 }
13100
13101
13102 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13103 PyObject *resultobj = 0;
13104 wxInputStream *arg1 = 0 ;
13105 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13106 int arg3 = (int) -1 ;
13107 wxImage *result = 0 ;
13108 wxPyInputStream *temp1 ;
13109 bool created1 ;
13110 long val2 ;
13111 int ecode2 = 0 ;
13112 int val3 ;
13113 int ecode3 = 0 ;
13114 PyObject * obj0 = 0 ;
13115 PyObject * obj1 = 0 ;
13116 PyObject * obj2 = 0 ;
13117 char * kwnames[] = {
13118 (char *) "stream",(char *) "type",(char *) "index", NULL
13119 };
13120
13121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13122 {
13123 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13124 arg1 = temp1->m_wxis;
13125 created1 = false;
13126 } else {
13127 PyErr_Clear(); // clear the failure of the wxPyConvert above
13128 arg1 = wxPyCBInputStream_create(obj0, false);
13129 if (arg1 == NULL) {
13130 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13131 SWIG_fail;
13132 }
13133 created1 = true;
13134 }
13135 }
13136 if (obj1) {
13137 ecode2 = SWIG_AsVal_long(obj1, &val2);
13138 if (!SWIG_IsOK(ecode2)) {
13139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13140 }
13141 arg2 = static_cast< long >(val2);
13142 }
13143 if (obj2) {
13144 ecode3 = SWIG_AsVal_int(obj2, &val3);
13145 if (!SWIG_IsOK(ecode3)) {
13146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13147 }
13148 arg3 = static_cast< int >(val3);
13149 }
13150 {
13151 PyThreadState* __tstate = wxPyBeginAllowThreads();
13152 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13157 {
13158 if (created1) delete arg1;
13159 }
13160 return resultobj;
13161 fail:
13162 {
13163 if (created1) delete arg1;
13164 }
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = 0;
13171 wxInputStream *arg1 = 0 ;
13172 wxString *arg2 = 0 ;
13173 int arg3 = (int) -1 ;
13174 wxImage *result = 0 ;
13175 wxPyInputStream *temp1 ;
13176 bool created1 ;
13177 bool temp2 = false ;
13178 int val3 ;
13179 int ecode3 = 0 ;
13180 PyObject * obj0 = 0 ;
13181 PyObject * obj1 = 0 ;
13182 PyObject * obj2 = 0 ;
13183 char * kwnames[] = {
13184 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13185 };
13186
13187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13188 {
13189 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13190 arg1 = temp1->m_wxis;
13191 created1 = false;
13192 } else {
13193 PyErr_Clear(); // clear the failure of the wxPyConvert above
13194 arg1 = wxPyCBInputStream_create(obj0, false);
13195 if (arg1 == NULL) {
13196 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13197 SWIG_fail;
13198 }
13199 created1 = true;
13200 }
13201 }
13202 {
13203 arg2 = wxString_in_helper(obj1);
13204 if (arg2 == NULL) SWIG_fail;
13205 temp2 = true;
13206 }
13207 if (obj2) {
13208 ecode3 = SWIG_AsVal_int(obj2, &val3);
13209 if (!SWIG_IsOK(ecode3)) {
13210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13211 }
13212 arg3 = static_cast< int >(val3);
13213 }
13214 {
13215 PyThreadState* __tstate = wxPyBeginAllowThreads();
13216 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13221 {
13222 if (created1) delete arg1;
13223 }
13224 {
13225 if (temp2)
13226 delete arg2;
13227 }
13228 return resultobj;
13229 fail:
13230 {
13231 if (created1) delete arg1;
13232 }
13233 {
13234 if (temp2)
13235 delete arg2;
13236 }
13237 return NULL;
13238 }
13239
13240
13241 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13242 PyObject *resultobj = 0;
13243 int arg1 = (int) 0 ;
13244 int arg2 = (int) 0 ;
13245 bool arg3 = (bool) true ;
13246 wxImage *result = 0 ;
13247 int val1 ;
13248 int ecode1 = 0 ;
13249 int val2 ;
13250 int ecode2 = 0 ;
13251 bool val3 ;
13252 int ecode3 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 PyObject * obj2 = 0 ;
13256 char * kwnames[] = {
13257 (char *) "width",(char *) "height",(char *) "clear", NULL
13258 };
13259
13260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13261 if (obj0) {
13262 ecode1 = SWIG_AsVal_int(obj0, &val1);
13263 if (!SWIG_IsOK(ecode1)) {
13264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13265 }
13266 arg1 = static_cast< int >(val1);
13267 }
13268 if (obj1) {
13269 ecode2 = SWIG_AsVal_int(obj1, &val2);
13270 if (!SWIG_IsOK(ecode2)) {
13271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13272 }
13273 arg2 = static_cast< int >(val2);
13274 }
13275 if (obj2) {
13276 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13277 if (!SWIG_IsOK(ecode3)) {
13278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13279 }
13280 arg3 = static_cast< bool >(val3);
13281 }
13282 {
13283 PyThreadState* __tstate = wxPyBeginAllowThreads();
13284 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13285 wxPyEndAllowThreads(__tstate);
13286 if (PyErr_Occurred()) SWIG_fail;
13287 }
13288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj = 0;
13297 wxBitmap *arg1 = 0 ;
13298 wxImage *result = 0 ;
13299 void *argp1 = 0 ;
13300 int res1 = 0 ;
13301 PyObject * obj0 = 0 ;
13302 char * kwnames[] = {
13303 (char *) "bitmap", NULL
13304 };
13305
13306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13307 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13308 if (!SWIG_IsOK(res1)) {
13309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13310 }
13311 if (!argp1) {
13312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13313 }
13314 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13315 {
13316 if (!wxPyCheckForApp()) SWIG_fail;
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj = 0;
13331 int arg1 ;
13332 int arg2 ;
13333 buffer arg3 ;
13334 int arg4 ;
13335 wxImage *result = 0 ;
13336 int val1 ;
13337 int ecode1 = 0 ;
13338 int val2 ;
13339 int ecode2 = 0 ;
13340 PyObject * obj0 = 0 ;
13341 PyObject * obj1 = 0 ;
13342 PyObject * obj2 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "width",(char *) "height",(char *) "data", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13348 ecode1 = SWIG_AsVal_int(obj0, &val1);
13349 if (!SWIG_IsOK(ecode1)) {
13350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13351 }
13352 arg1 = static_cast< int >(val1);
13353 ecode2 = SWIG_AsVal_int(obj1, &val2);
13354 if (!SWIG_IsOK(ecode2)) {
13355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13356 }
13357 arg2 = static_cast< int >(val2);
13358 {
13359 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13360 }
13361 {
13362 PyThreadState* __tstate = wxPyBeginAllowThreads();
13363 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13364 wxPyEndAllowThreads(__tstate);
13365 if (PyErr_Occurred()) SWIG_fail;
13366 }
13367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13375 PyObject *resultobj = 0;
13376 int arg1 ;
13377 int arg2 ;
13378 buffer arg3 ;
13379 int arg4 ;
13380 buffer arg5 ;
13381 int arg6 ;
13382 wxImage *result = 0 ;
13383 int val1 ;
13384 int ecode1 = 0 ;
13385 int val2 ;
13386 int ecode2 = 0 ;
13387 PyObject * obj0 = 0 ;
13388 PyObject * obj1 = 0 ;
13389 PyObject * obj2 = 0 ;
13390 PyObject * obj3 = 0 ;
13391 char * kwnames[] = {
13392 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13393 };
13394
13395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13396 ecode1 = SWIG_AsVal_int(obj0, &val1);
13397 if (!SWIG_IsOK(ecode1)) {
13398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13399 }
13400 arg1 = static_cast< int >(val1);
13401 ecode2 = SWIG_AsVal_int(obj1, &val2);
13402 if (!SWIG_IsOK(ecode2)) {
13403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13404 }
13405 arg2 = static_cast< int >(val2);
13406 {
13407 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13408 }
13409 {
13410 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13411 }
13412 {
13413 PyThreadState* __tstate = wxPyBeginAllowThreads();
13414 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13415 wxPyEndAllowThreads(__tstate);
13416 if (PyErr_Occurred()) SWIG_fail;
13417 }
13418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13419 return resultobj;
13420 fail:
13421 return NULL;
13422 }
13423
13424
13425 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13426 PyObject *resultobj = 0;
13427 wxImage *arg1 = (wxImage *) 0 ;
13428 int arg2 ;
13429 int arg3 ;
13430 bool arg4 = (bool) true ;
13431 void *argp1 = 0 ;
13432 int res1 = 0 ;
13433 int val2 ;
13434 int ecode2 = 0 ;
13435 int val3 ;
13436 int ecode3 = 0 ;
13437 bool val4 ;
13438 int ecode4 = 0 ;
13439 PyObject * obj0 = 0 ;
13440 PyObject * obj1 = 0 ;
13441 PyObject * obj2 = 0 ;
13442 PyObject * obj3 = 0 ;
13443 char * kwnames[] = {
13444 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13445 };
13446
13447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13449 if (!SWIG_IsOK(res1)) {
13450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13451 }
13452 arg1 = reinterpret_cast< wxImage * >(argp1);
13453 ecode2 = SWIG_AsVal_int(obj1, &val2);
13454 if (!SWIG_IsOK(ecode2)) {
13455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13456 }
13457 arg2 = static_cast< int >(val2);
13458 ecode3 = SWIG_AsVal_int(obj2, &val3);
13459 if (!SWIG_IsOK(ecode3)) {
13460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13461 }
13462 arg3 = static_cast< int >(val3);
13463 if (obj3) {
13464 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13465 if (!SWIG_IsOK(ecode4)) {
13466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13467 }
13468 arg4 = static_cast< bool >(val4);
13469 }
13470 {
13471 PyThreadState* __tstate = wxPyBeginAllowThreads();
13472 (arg1)->Create(arg2,arg3,arg4);
13473 wxPyEndAllowThreads(__tstate);
13474 if (PyErr_Occurred()) SWIG_fail;
13475 }
13476 resultobj = SWIG_Py_Void();
13477 return resultobj;
13478 fail:
13479 return NULL;
13480 }
13481
13482
13483 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13484 PyObject *resultobj = 0;
13485 wxImage *arg1 = (wxImage *) 0 ;
13486 void *argp1 = 0 ;
13487 int res1 = 0 ;
13488 PyObject *swig_obj[1] ;
13489
13490 if (!args) SWIG_fail;
13491 swig_obj[0] = args;
13492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13493 if (!SWIG_IsOK(res1)) {
13494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13495 }
13496 arg1 = reinterpret_cast< wxImage * >(argp1);
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 (arg1)->Destroy();
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 resultobj = SWIG_Py_Void();
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 int arg2 ;
13514 int arg3 ;
13515 SwigValueWrapper<wxImage > result;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 int val2 ;
13519 int ecode2 = 0 ;
13520 int val3 ;
13521 int ecode3 = 0 ;
13522 PyObject * obj0 = 0 ;
13523 PyObject * obj1 = 0 ;
13524 PyObject * obj2 = 0 ;
13525 char * kwnames[] = {
13526 (char *) "self",(char *) "width",(char *) "height", NULL
13527 };
13528
13529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13531 if (!SWIG_IsOK(res1)) {
13532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13533 }
13534 arg1 = reinterpret_cast< wxImage * >(argp1);
13535 ecode2 = SWIG_AsVal_int(obj1, &val2);
13536 if (!SWIG_IsOK(ecode2)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13538 }
13539 arg2 = static_cast< int >(val2);
13540 ecode3 = SWIG_AsVal_int(obj2, &val3);
13541 if (!SWIG_IsOK(ecode3)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13543 }
13544 arg3 = static_cast< int >(val3);
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 result = (arg1)->Scale(arg2,arg3);
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = 0;
13560 wxImage *arg1 = (wxImage *) 0 ;
13561 int arg2 ;
13562 int arg3 ;
13563 SwigValueWrapper<wxImage > result;
13564 void *argp1 = 0 ;
13565 int res1 = 0 ;
13566 int val2 ;
13567 int ecode2 = 0 ;
13568 int val3 ;
13569 int ecode3 = 0 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13579 if (!SWIG_IsOK(res1)) {
13580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13581 }
13582 arg1 = reinterpret_cast< wxImage * >(argp1);
13583 ecode2 = SWIG_AsVal_int(obj1, &val2);
13584 if (!SWIG_IsOK(ecode2)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13586 }
13587 arg2 = static_cast< int >(val2);
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 {
13594 PyThreadState* __tstate = wxPyBeginAllowThreads();
13595 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13596 wxPyEndAllowThreads(__tstate);
13597 if (PyErr_Occurred()) SWIG_fail;
13598 }
13599 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13600 return resultobj;
13601 fail:
13602 return NULL;
13603 }
13604
13605
13606 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13607 PyObject *resultobj = 0;
13608 wxImage *arg1 = (wxImage *) 0 ;
13609 int arg2 ;
13610 int arg3 ;
13611 wxImage *result = 0 ;
13612 void *argp1 = 0 ;
13613 int res1 = 0 ;
13614 int val2 ;
13615 int ecode2 = 0 ;
13616 int val3 ;
13617 int ecode3 = 0 ;
13618 PyObject * obj0 = 0 ;
13619 PyObject * obj1 = 0 ;
13620 PyObject * obj2 = 0 ;
13621 char * kwnames[] = {
13622 (char *) "self",(char *) "width",(char *) "height", NULL
13623 };
13624
13625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13627 if (!SWIG_IsOK(res1)) {
13628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13629 }
13630 arg1 = reinterpret_cast< wxImage * >(argp1);
13631 ecode2 = SWIG_AsVal_int(obj1, &val2);
13632 if (!SWIG_IsOK(ecode2)) {
13633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13634 }
13635 arg2 = static_cast< int >(val2);
13636 ecode3 = SWIG_AsVal_int(obj2, &val3);
13637 if (!SWIG_IsOK(ecode3)) {
13638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13639 }
13640 arg3 = static_cast< int >(val3);
13641 {
13642 PyThreadState* __tstate = wxPyBeginAllowThreads();
13643 {
13644 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13645 result = (wxImage *) &_result_ref;
13646 }
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13651 return resultobj;
13652 fail:
13653 return NULL;
13654 }
13655
13656
13657 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj = 0;
13659 wxImage *arg1 = (wxImage *) 0 ;
13660 wxSize *arg2 = 0 ;
13661 wxPoint *arg3 = 0 ;
13662 int arg4 = (int) -1 ;
13663 int arg5 = (int) -1 ;
13664 int arg6 = (int) -1 ;
13665 wxImage *result = 0 ;
13666 void *argp1 = 0 ;
13667 int res1 = 0 ;
13668 wxSize temp2 ;
13669 wxPoint temp3 ;
13670 int val4 ;
13671 int ecode4 = 0 ;
13672 int val5 ;
13673 int ecode5 = 0 ;
13674 int val6 ;
13675 int ecode6 = 0 ;
13676 PyObject * obj0 = 0 ;
13677 PyObject * obj1 = 0 ;
13678 PyObject * obj2 = 0 ;
13679 PyObject * obj3 = 0 ;
13680 PyObject * obj4 = 0 ;
13681 PyObject * obj5 = 0 ;
13682 char * kwnames[] = {
13683 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13684 };
13685
13686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13688 if (!SWIG_IsOK(res1)) {
13689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13690 }
13691 arg1 = reinterpret_cast< wxImage * >(argp1);
13692 {
13693 arg2 = &temp2;
13694 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13695 }
13696 {
13697 arg3 = &temp3;
13698 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13699 }
13700 if (obj3) {
13701 ecode4 = SWIG_AsVal_int(obj3, &val4);
13702 if (!SWIG_IsOK(ecode4)) {
13703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13704 }
13705 arg4 = static_cast< int >(val4);
13706 }
13707 if (obj4) {
13708 ecode5 = SWIG_AsVal_int(obj4, &val5);
13709 if (!SWIG_IsOK(ecode5)) {
13710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13711 }
13712 arg5 = static_cast< int >(val5);
13713 }
13714 if (obj5) {
13715 ecode6 = SWIG_AsVal_int(obj5, &val6);
13716 if (!SWIG_IsOK(ecode6)) {
13717 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13718 }
13719 arg6 = static_cast< int >(val6);
13720 }
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 {
13724 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
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_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13738 PyObject *resultobj = 0;
13739 wxImage *arg1 = (wxImage *) 0 ;
13740 int arg2 ;
13741 int arg3 ;
13742 byte arg4 ;
13743 byte arg5 ;
13744 byte arg6 ;
13745 void *argp1 = 0 ;
13746 int res1 = 0 ;
13747 int val2 ;
13748 int ecode2 = 0 ;
13749 int val3 ;
13750 int ecode3 = 0 ;
13751 unsigned char val4 ;
13752 int ecode4 = 0 ;
13753 unsigned char val5 ;
13754 int ecode5 = 0 ;
13755 unsigned char val6 ;
13756 int ecode6 = 0 ;
13757 PyObject * obj0 = 0 ;
13758 PyObject * obj1 = 0 ;
13759 PyObject * obj2 = 0 ;
13760 PyObject * obj3 = 0 ;
13761 PyObject * obj4 = 0 ;
13762 PyObject * obj5 = 0 ;
13763 char * kwnames[] = {
13764 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13765 };
13766
13767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13769 if (!SWIG_IsOK(res1)) {
13770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13771 }
13772 arg1 = reinterpret_cast< wxImage * >(argp1);
13773 ecode2 = SWIG_AsVal_int(obj1, &val2);
13774 if (!SWIG_IsOK(ecode2)) {
13775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13776 }
13777 arg2 = static_cast< int >(val2);
13778 ecode3 = SWIG_AsVal_int(obj2, &val3);
13779 if (!SWIG_IsOK(ecode3)) {
13780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13781 }
13782 arg3 = static_cast< int >(val3);
13783 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13784 if (!SWIG_IsOK(ecode4)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13786 }
13787 arg4 = static_cast< byte >(val4);
13788 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13789 if (!SWIG_IsOK(ecode5)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13791 }
13792 arg5 = static_cast< byte >(val5);
13793 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13794 if (!SWIG_IsOK(ecode6)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13796 }
13797 arg6 = static_cast< byte >(val6);
13798 {
13799 PyThreadState* __tstate = wxPyBeginAllowThreads();
13800 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13801 wxPyEndAllowThreads(__tstate);
13802 if (PyErr_Occurred()) SWIG_fail;
13803 }
13804 resultobj = SWIG_Py_Void();
13805 return resultobj;
13806 fail:
13807 return NULL;
13808 }
13809
13810
13811 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13812 PyObject *resultobj = 0;
13813 wxImage *arg1 = (wxImage *) 0 ;
13814 wxRect *arg2 = 0 ;
13815 byte arg3 ;
13816 byte arg4 ;
13817 byte arg5 ;
13818 void *argp1 = 0 ;
13819 int res1 = 0 ;
13820 wxRect temp2 ;
13821 unsigned char val3 ;
13822 int ecode3 = 0 ;
13823 unsigned char val4 ;
13824 int ecode4 = 0 ;
13825 unsigned char val5 ;
13826 int ecode5 = 0 ;
13827 PyObject * obj0 = 0 ;
13828 PyObject * obj1 = 0 ;
13829 PyObject * obj2 = 0 ;
13830 PyObject * obj3 = 0 ;
13831 PyObject * obj4 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13838 if (!SWIG_IsOK(res1)) {
13839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13840 }
13841 arg1 = reinterpret_cast< wxImage * >(argp1);
13842 {
13843 arg2 = &temp2;
13844 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13845 }
13846 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13847 if (!SWIG_IsOK(ecode3)) {
13848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13849 }
13850 arg3 = static_cast< byte >(val3);
13851 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13852 if (!SWIG_IsOK(ecode4)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13854 }
13855 arg4 = static_cast< byte >(val4);
13856 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13857 if (!SWIG_IsOK(ecode5)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13859 }
13860 arg5 = static_cast< byte >(val5);
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_Py_Void();
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 int arg2 ;
13878 int arg3 ;
13879 byte result;
13880 void *argp1 = 0 ;
13881 int res1 = 0 ;
13882 int val2 ;
13883 int ecode2 = 0 ;
13884 int val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *) "x",(char *) "y", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13897 }
13898 arg1 = reinterpret_cast< wxImage * >(argp1);
13899 ecode2 = SWIG_AsVal_int(obj1, &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13902 }
13903 arg2 = static_cast< int >(val2);
13904 ecode3 = SWIG_AsVal_int(obj2, &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13907 }
13908 arg3 = static_cast< int >(val3);
13909 {
13910 PyThreadState* __tstate = wxPyBeginAllowThreads();
13911 result = (byte)(arg1)->GetRed(arg2,arg3);
13912 wxPyEndAllowThreads(__tstate);
13913 if (PyErr_Occurred()) SWIG_fail;
13914 }
13915 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13916 return resultobj;
13917 fail:
13918 return NULL;
13919 }
13920
13921
13922 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13923 PyObject *resultobj = 0;
13924 wxImage *arg1 = (wxImage *) 0 ;
13925 int arg2 ;
13926 int arg3 ;
13927 byte result;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 int val2 ;
13931 int ecode2 = 0 ;
13932 int val3 ;
13933 int ecode3 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 PyObject * obj2 = 0 ;
13937 char * kwnames[] = {
13938 (char *) "self",(char *) "x",(char *) "y", NULL
13939 };
13940
13941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13943 if (!SWIG_IsOK(res1)) {
13944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13945 }
13946 arg1 = reinterpret_cast< wxImage * >(argp1);
13947 ecode2 = SWIG_AsVal_int(obj1, &val2);
13948 if (!SWIG_IsOK(ecode2)) {
13949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13950 }
13951 arg2 = static_cast< int >(val2);
13952 ecode3 = SWIG_AsVal_int(obj2, &val3);
13953 if (!SWIG_IsOK(ecode3)) {
13954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13955 }
13956 arg3 = static_cast< int >(val3);
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 result = (byte)(arg1)->GetGreen(arg2,arg3);
13960 wxPyEndAllowThreads(__tstate);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 }
13963 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13964 return resultobj;
13965 fail:
13966 return NULL;
13967 }
13968
13969
13970 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13971 PyObject *resultobj = 0;
13972 wxImage *arg1 = (wxImage *) 0 ;
13973 int arg2 ;
13974 int arg3 ;
13975 byte result;
13976 void *argp1 = 0 ;
13977 int res1 = 0 ;
13978 int val2 ;
13979 int ecode2 = 0 ;
13980 int val3 ;
13981 int ecode3 = 0 ;
13982 PyObject * obj0 = 0 ;
13983 PyObject * obj1 = 0 ;
13984 PyObject * obj2 = 0 ;
13985 char * kwnames[] = {
13986 (char *) "self",(char *) "x",(char *) "y", NULL
13987 };
13988
13989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13991 if (!SWIG_IsOK(res1)) {
13992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13993 }
13994 arg1 = reinterpret_cast< wxImage * >(argp1);
13995 ecode2 = SWIG_AsVal_int(obj1, &val2);
13996 if (!SWIG_IsOK(ecode2)) {
13997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13998 }
13999 arg2 = static_cast< int >(val2);
14000 ecode3 = SWIG_AsVal_int(obj2, &val3);
14001 if (!SWIG_IsOK(ecode3)) {
14002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14003 }
14004 arg3 = static_cast< int >(val3);
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 result = (byte)(arg1)->GetBlue(arg2,arg3);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14012 return resultobj;
14013 fail:
14014 return NULL;
14015 }
14016
14017
14018 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14019 PyObject *resultobj = 0;
14020 wxImage *arg1 = (wxImage *) 0 ;
14021 int arg2 ;
14022 int arg3 ;
14023 byte arg4 ;
14024 void *argp1 = 0 ;
14025 int res1 = 0 ;
14026 int val2 ;
14027 int ecode2 = 0 ;
14028 int val3 ;
14029 int ecode3 = 0 ;
14030 unsigned char val4 ;
14031 int ecode4 = 0 ;
14032 PyObject * obj0 = 0 ;
14033 PyObject * obj1 = 0 ;
14034 PyObject * obj2 = 0 ;
14035 PyObject * obj3 = 0 ;
14036 char * kwnames[] = {
14037 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14038 };
14039
14040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14042 if (!SWIG_IsOK(res1)) {
14043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14044 }
14045 arg1 = reinterpret_cast< wxImage * >(argp1);
14046 ecode2 = SWIG_AsVal_int(obj1, &val2);
14047 if (!SWIG_IsOK(ecode2)) {
14048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14049 }
14050 arg2 = static_cast< int >(val2);
14051 ecode3 = SWIG_AsVal_int(obj2, &val3);
14052 if (!SWIG_IsOK(ecode3)) {
14053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14054 }
14055 arg3 = static_cast< int >(val3);
14056 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14057 if (!SWIG_IsOK(ecode4)) {
14058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14059 }
14060 arg4 = static_cast< byte >(val4);
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 (arg1)->SetAlpha(arg2,arg3,arg4);
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_Py_Void();
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxImage *arg1 = (wxImage *) 0 ;
14077 int arg2 ;
14078 int arg3 ;
14079 byte result;
14080 void *argp1 = 0 ;
14081 int res1 = 0 ;
14082 int val2 ;
14083 int ecode2 = 0 ;
14084 int val3 ;
14085 int ecode3 = 0 ;
14086 PyObject * obj0 = 0 ;
14087 PyObject * obj1 = 0 ;
14088 PyObject * obj2 = 0 ;
14089 char * kwnames[] = {
14090 (char *) "self",(char *) "x",(char *) "y", NULL
14091 };
14092
14093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14095 if (!SWIG_IsOK(res1)) {
14096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14097 }
14098 arg1 = reinterpret_cast< wxImage * >(argp1);
14099 ecode2 = SWIG_AsVal_int(obj1, &val2);
14100 if (!SWIG_IsOK(ecode2)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14102 }
14103 arg2 = static_cast< int >(val2);
14104 ecode3 = SWIG_AsVal_int(obj2, &val3);
14105 if (!SWIG_IsOK(ecode3)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14107 }
14108 arg3 = static_cast< int >(val3);
14109 {
14110 PyThreadState* __tstate = wxPyBeginAllowThreads();
14111 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14116 return resultobj;
14117 fail:
14118 return NULL;
14119 }
14120
14121
14122 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14123 PyObject *resultobj = 0;
14124 wxImage *arg1 = (wxImage *) 0 ;
14125 bool result;
14126 void *argp1 = 0 ;
14127 int res1 = 0 ;
14128 PyObject *swig_obj[1] ;
14129
14130 if (!args) SWIG_fail;
14131 swig_obj[0] = args;
14132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14133 if (!SWIG_IsOK(res1)) {
14134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14135 }
14136 arg1 = reinterpret_cast< wxImage * >(argp1);
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 result = (bool)(arg1)->HasAlpha();
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14145 }
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14153 PyObject *resultobj = 0;
14154 wxImage *arg1 = (wxImage *) 0 ;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 PyObject *swig_obj[1] ;
14158
14159 if (!args) SWIG_fail;
14160 swig_obj[0] = args;
14161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14164 }
14165 arg1 = reinterpret_cast< wxImage * >(argp1);
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 (arg1)->InitAlpha();
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 resultobj = SWIG_Py_Void();
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj = 0;
14181 wxImage *arg1 = (wxImage *) 0 ;
14182 int arg2 ;
14183 int arg3 ;
14184 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14185 bool result;
14186 void *argp1 = 0 ;
14187 int res1 = 0 ;
14188 int val2 ;
14189 int ecode2 = 0 ;
14190 int val3 ;
14191 int ecode3 = 0 ;
14192 unsigned char val4 ;
14193 int ecode4 = 0 ;
14194 PyObject * obj0 = 0 ;
14195 PyObject * obj1 = 0 ;
14196 PyObject * obj2 = 0 ;
14197 PyObject * obj3 = 0 ;
14198 char * kwnames[] = {
14199 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14200 };
14201
14202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14204 if (!SWIG_IsOK(res1)) {
14205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14206 }
14207 arg1 = reinterpret_cast< wxImage * >(argp1);
14208 ecode2 = SWIG_AsVal_int(obj1, &val2);
14209 if (!SWIG_IsOK(ecode2)) {
14210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14211 }
14212 arg2 = static_cast< int >(val2);
14213 ecode3 = SWIG_AsVal_int(obj2, &val3);
14214 if (!SWIG_IsOK(ecode3)) {
14215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14216 }
14217 arg3 = static_cast< int >(val3);
14218 if (obj3) {
14219 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14220 if (!SWIG_IsOK(ecode4)) {
14221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14222 }
14223 arg4 = static_cast< byte >(val4);
14224 }
14225 {
14226 PyThreadState* __tstate = wxPyBeginAllowThreads();
14227 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 {
14232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14233 }
14234 return resultobj;
14235 fail:
14236 return NULL;
14237 }
14238
14239
14240 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14241 PyObject *resultobj = 0;
14242 wxImage *arg1 = (wxImage *) 0 ;
14243 byte *arg2 = (byte *) 0 ;
14244 byte *arg3 = (byte *) 0 ;
14245 byte *arg4 = (byte *) 0 ;
14246 byte arg5 = (byte) 0 ;
14247 byte arg6 = (byte) 0 ;
14248 byte arg7 = (byte) 0 ;
14249 bool result;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 byte temp2 ;
14253 int res2 = SWIG_TMPOBJ ;
14254 byte temp3 ;
14255 int res3 = SWIG_TMPOBJ ;
14256 byte temp4 ;
14257 int res4 = SWIG_TMPOBJ ;
14258 unsigned char val5 ;
14259 int ecode5 = 0 ;
14260 unsigned char val6 ;
14261 int ecode6 = 0 ;
14262 unsigned char val7 ;
14263 int ecode7 = 0 ;
14264 PyObject * obj0 = 0 ;
14265 PyObject * obj1 = 0 ;
14266 PyObject * obj2 = 0 ;
14267 PyObject * obj3 = 0 ;
14268 char * kwnames[] = {
14269 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14270 };
14271
14272 arg2 = &temp2;
14273 arg3 = &temp3;
14274 arg4 = &temp4;
14275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14277 if (!SWIG_IsOK(res1)) {
14278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14279 }
14280 arg1 = reinterpret_cast< wxImage * >(argp1);
14281 if (obj1) {
14282 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14283 if (!SWIG_IsOK(ecode5)) {
14284 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14285 }
14286 arg5 = static_cast< byte >(val5);
14287 }
14288 if (obj2) {
14289 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14290 if (!SWIG_IsOK(ecode6)) {
14291 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14292 }
14293 arg6 = static_cast< byte >(val6);
14294 }
14295 if (obj3) {
14296 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14297 if (!SWIG_IsOK(ecode7)) {
14298 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14299 }
14300 arg7 = static_cast< byte >(val7);
14301 }
14302 {
14303 PyThreadState* __tstate = wxPyBeginAllowThreads();
14304 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14305 wxPyEndAllowThreads(__tstate);
14306 if (PyErr_Occurred()) SWIG_fail;
14307 }
14308 {
14309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14310 }
14311 if (SWIG_IsTmpObj(res2)) {
14312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14313 } else {
14314 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14316 }
14317 if (SWIG_IsTmpObj(res3)) {
14318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14319 } else {
14320 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14322 }
14323 if (SWIG_IsTmpObj(res4)) {
14324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14325 } else {
14326 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14328 }
14329 return resultobj;
14330 fail:
14331 return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj = 0;
14337 wxImage *arg1 = (wxImage *) 0 ;
14338 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14339 bool result;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 unsigned char val2 ;
14343 int ecode2 = 0 ;
14344 PyObject * obj0 = 0 ;
14345 PyObject * obj1 = 0 ;
14346 char * kwnames[] = {
14347 (char *) "self",(char *) "threshold", NULL
14348 };
14349
14350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14352 if (!SWIG_IsOK(res1)) {
14353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14354 }
14355 arg1 = reinterpret_cast< wxImage * >(argp1);
14356 if (obj1) {
14357 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14358 if (!SWIG_IsOK(ecode2)) {
14359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14360 }
14361 arg2 = static_cast< byte >(val2);
14362 }
14363 {
14364 PyThreadState* __tstate = wxPyBeginAllowThreads();
14365 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 {
14370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14371 }
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14379 PyObject *resultobj = 0;
14380 wxImage *arg1 = (wxImage *) 0 ;
14381 byte arg2 ;
14382 byte arg3 ;
14383 byte arg4 ;
14384 bool result;
14385 void *argp1 = 0 ;
14386 int res1 = 0 ;
14387 unsigned char val2 ;
14388 int ecode2 = 0 ;
14389 unsigned char val3 ;
14390 int ecode3 = 0 ;
14391 unsigned char val4 ;
14392 int ecode4 = 0 ;
14393 PyObject * obj0 = 0 ;
14394 PyObject * obj1 = 0 ;
14395 PyObject * obj2 = 0 ;
14396 PyObject * obj3 = 0 ;
14397 char * kwnames[] = {
14398 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14399 };
14400
14401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14403 if (!SWIG_IsOK(res1)) {
14404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14405 }
14406 arg1 = reinterpret_cast< wxImage * >(argp1);
14407 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14408 if (!SWIG_IsOK(ecode2)) {
14409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14410 }
14411 arg2 = static_cast< byte >(val2);
14412 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14413 if (!SWIG_IsOK(ecode3)) {
14414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14415 }
14416 arg3 = static_cast< byte >(val3);
14417 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14418 if (!SWIG_IsOK(ecode4)) {
14419 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14420 }
14421 arg4 = static_cast< byte >(val4);
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 {
14429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14430 }
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj = 0;
14439 wxImage *arg1 = (wxImage *) 0 ;
14440 wxImage *arg2 = 0 ;
14441 byte arg3 ;
14442 byte arg4 ;
14443 byte arg5 ;
14444 bool result;
14445 void *argp1 = 0 ;
14446 int res1 = 0 ;
14447 void *argp2 = 0 ;
14448 int res2 = 0 ;
14449 unsigned char val3 ;
14450 int ecode3 = 0 ;
14451 unsigned char val4 ;
14452 int ecode4 = 0 ;
14453 unsigned char val5 ;
14454 int ecode5 = 0 ;
14455 PyObject * obj0 = 0 ;
14456 PyObject * obj1 = 0 ;
14457 PyObject * obj2 = 0 ;
14458 PyObject * obj3 = 0 ;
14459 PyObject * obj4 = 0 ;
14460 char * kwnames[] = {
14461 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14462 };
14463
14464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14466 if (!SWIG_IsOK(res1)) {
14467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14468 }
14469 arg1 = reinterpret_cast< wxImage * >(argp1);
14470 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14471 if (!SWIG_IsOK(res2)) {
14472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14473 }
14474 if (!argp2) {
14475 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14476 }
14477 arg2 = reinterpret_cast< wxImage * >(argp2);
14478 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14479 if (!SWIG_IsOK(ecode3)) {
14480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14481 }
14482 arg3 = static_cast< byte >(val3);
14483 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14484 if (!SWIG_IsOK(ecode4)) {
14485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14486 }
14487 arg4 = static_cast< byte >(val4);
14488 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14489 if (!SWIG_IsOK(ecode5)) {
14490 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14491 }
14492 arg5 = static_cast< byte >(val5);
14493 {
14494 PyThreadState* __tstate = wxPyBeginAllowThreads();
14495 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14496 wxPyEndAllowThreads(__tstate);
14497 if (PyErr_Occurred()) SWIG_fail;
14498 }
14499 {
14500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14501 }
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14509 PyObject *resultobj = 0;
14510 wxString *arg1 = 0 ;
14511 bool result;
14512 bool temp1 = false ;
14513 PyObject * obj0 = 0 ;
14514 char * kwnames[] = {
14515 (char *) "filename", NULL
14516 };
14517
14518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14519 {
14520 arg1 = wxString_in_helper(obj0);
14521 if (arg1 == NULL) SWIG_fail;
14522 temp1 = true;
14523 }
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14527 wxPyEndAllowThreads(__tstate);
14528 if (PyErr_Occurred()) SWIG_fail;
14529 }
14530 {
14531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14532 }
14533 {
14534 if (temp1)
14535 delete arg1;
14536 }
14537 return resultobj;
14538 fail:
14539 {
14540 if (temp1)
14541 delete arg1;
14542 }
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = 0;
14549 wxString *arg1 = 0 ;
14550 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14551 int result;
14552 bool temp1 = false ;
14553 long val2 ;
14554 int ecode2 = 0 ;
14555 PyObject * obj0 = 0 ;
14556 PyObject * obj1 = 0 ;
14557 char * kwnames[] = {
14558 (char *) "filename",(char *) "type", NULL
14559 };
14560
14561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14562 {
14563 arg1 = wxString_in_helper(obj0);
14564 if (arg1 == NULL) SWIG_fail;
14565 temp1 = true;
14566 }
14567 if (obj1) {
14568 ecode2 = SWIG_AsVal_long(obj1, &val2);
14569 if (!SWIG_IsOK(ecode2)) {
14570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14571 }
14572 arg2 = static_cast< long >(val2);
14573 }
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 resultobj = SWIG_From_int(static_cast< int >(result));
14581 {
14582 if (temp1)
14583 delete arg1;
14584 }
14585 return resultobj;
14586 fail:
14587 {
14588 if (temp1)
14589 delete arg1;
14590 }
14591 return NULL;
14592 }
14593
14594
14595 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14596 PyObject *resultobj = 0;
14597 wxImage *arg1 = (wxImage *) 0 ;
14598 wxString *arg2 = 0 ;
14599 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14600 int arg4 = (int) -1 ;
14601 bool result;
14602 void *argp1 = 0 ;
14603 int res1 = 0 ;
14604 bool temp2 = false ;
14605 long val3 ;
14606 int ecode3 = 0 ;
14607 int val4 ;
14608 int ecode4 = 0 ;
14609 PyObject * obj0 = 0 ;
14610 PyObject * obj1 = 0 ;
14611 PyObject * obj2 = 0 ;
14612 PyObject * obj3 = 0 ;
14613 char * kwnames[] = {
14614 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14615 };
14616
14617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14619 if (!SWIG_IsOK(res1)) {
14620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14621 }
14622 arg1 = reinterpret_cast< wxImage * >(argp1);
14623 {
14624 arg2 = wxString_in_helper(obj1);
14625 if (arg2 == NULL) SWIG_fail;
14626 temp2 = true;
14627 }
14628 if (obj2) {
14629 ecode3 = SWIG_AsVal_long(obj2, &val3);
14630 if (!SWIG_IsOK(ecode3)) {
14631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14632 }
14633 arg3 = static_cast< long >(val3);
14634 }
14635 if (obj3) {
14636 ecode4 = SWIG_AsVal_int(obj3, &val4);
14637 if (!SWIG_IsOK(ecode4)) {
14638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14639 }
14640 arg4 = static_cast< int >(val4);
14641 }
14642 {
14643 PyThreadState* __tstate = wxPyBeginAllowThreads();
14644 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14645 wxPyEndAllowThreads(__tstate);
14646 if (PyErr_Occurred()) SWIG_fail;
14647 }
14648 {
14649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14650 }
14651 {
14652 if (temp2)
14653 delete arg2;
14654 }
14655 return resultobj;
14656 fail:
14657 {
14658 if (temp2)
14659 delete arg2;
14660 }
14661 return NULL;
14662 }
14663
14664
14665 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14666 PyObject *resultobj = 0;
14667 wxImage *arg1 = (wxImage *) 0 ;
14668 wxString *arg2 = 0 ;
14669 wxString *arg3 = 0 ;
14670 int arg4 = (int) -1 ;
14671 bool result;
14672 void *argp1 = 0 ;
14673 int res1 = 0 ;
14674 bool temp2 = false ;
14675 bool temp3 = false ;
14676 int val4 ;
14677 int ecode4 = 0 ;
14678 PyObject * obj0 = 0 ;
14679 PyObject * obj1 = 0 ;
14680 PyObject * obj2 = 0 ;
14681 PyObject * obj3 = 0 ;
14682 char * kwnames[] = {
14683 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14684 };
14685
14686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14690 }
14691 arg1 = reinterpret_cast< wxImage * >(argp1);
14692 {
14693 arg2 = wxString_in_helper(obj1);
14694 if (arg2 == NULL) SWIG_fail;
14695 temp2 = true;
14696 }
14697 {
14698 arg3 = wxString_in_helper(obj2);
14699 if (arg3 == NULL) SWIG_fail;
14700 temp3 = true;
14701 }
14702 if (obj3) {
14703 ecode4 = SWIG_AsVal_int(obj3, &val4);
14704 if (!SWIG_IsOK(ecode4)) {
14705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14706 }
14707 arg4 = static_cast< int >(val4);
14708 }
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 {
14716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14717 }
14718 {
14719 if (temp2)
14720 delete arg2;
14721 }
14722 {
14723 if (temp3)
14724 delete arg3;
14725 }
14726 return resultobj;
14727 fail:
14728 {
14729 if (temp2)
14730 delete arg2;
14731 }
14732 {
14733 if (temp3)
14734 delete arg3;
14735 }
14736 return NULL;
14737 }
14738
14739
14740 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14741 PyObject *resultobj = 0;
14742 wxImage *arg1 = (wxImage *) 0 ;
14743 wxString *arg2 = 0 ;
14744 int arg3 ;
14745 bool result;
14746 void *argp1 = 0 ;
14747 int res1 = 0 ;
14748 bool temp2 = false ;
14749 int val3 ;
14750 int ecode3 = 0 ;
14751 PyObject * obj0 = 0 ;
14752 PyObject * obj1 = 0 ;
14753 PyObject * obj2 = 0 ;
14754 char * kwnames[] = {
14755 (char *) "self",(char *) "name",(char *) "type", NULL
14756 };
14757
14758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14760 if (!SWIG_IsOK(res1)) {
14761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14762 }
14763 arg1 = reinterpret_cast< wxImage * >(argp1);
14764 {
14765 arg2 = wxString_in_helper(obj1);
14766 if (arg2 == NULL) SWIG_fail;
14767 temp2 = true;
14768 }
14769 ecode3 = SWIG_AsVal_int(obj2, &val3);
14770 if (!SWIG_IsOK(ecode3)) {
14771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14772 }
14773 arg3 = static_cast< int >(val3);
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 {
14781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14782 }
14783 {
14784 if (temp2)
14785 delete arg2;
14786 }
14787 return resultobj;
14788 fail:
14789 {
14790 if (temp2)
14791 delete arg2;
14792 }
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj = 0;
14799 wxImage *arg1 = (wxImage *) 0 ;
14800 wxString *arg2 = 0 ;
14801 wxString *arg3 = 0 ;
14802 bool result;
14803 void *argp1 = 0 ;
14804 int res1 = 0 ;
14805 bool temp2 = false ;
14806 bool temp3 = false ;
14807 PyObject * obj0 = 0 ;
14808 PyObject * obj1 = 0 ;
14809 PyObject * obj2 = 0 ;
14810 char * kwnames[] = {
14811 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14812 };
14813
14814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14816 if (!SWIG_IsOK(res1)) {
14817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14818 }
14819 arg1 = reinterpret_cast< wxImage * >(argp1);
14820 {
14821 arg2 = wxString_in_helper(obj1);
14822 if (arg2 == NULL) SWIG_fail;
14823 temp2 = true;
14824 }
14825 {
14826 arg3 = wxString_in_helper(obj2);
14827 if (arg3 == NULL) SWIG_fail;
14828 temp3 = true;
14829 }
14830 {
14831 PyThreadState* __tstate = wxPyBeginAllowThreads();
14832 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14833 wxPyEndAllowThreads(__tstate);
14834 if (PyErr_Occurred()) SWIG_fail;
14835 }
14836 {
14837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14838 }
14839 {
14840 if (temp2)
14841 delete arg2;
14842 }
14843 {
14844 if (temp3)
14845 delete arg3;
14846 }
14847 return resultobj;
14848 fail:
14849 {
14850 if (temp2)
14851 delete arg2;
14852 }
14853 {
14854 if (temp3)
14855 delete arg3;
14856 }
14857 return NULL;
14858 }
14859
14860
14861 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj = 0;
14863 wxInputStream *arg1 = 0 ;
14864 bool result;
14865 wxPyInputStream *temp1 ;
14866 bool created1 ;
14867 PyObject * obj0 = 0 ;
14868 char * kwnames[] = {
14869 (char *) "stream", NULL
14870 };
14871
14872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14873 {
14874 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14875 arg1 = temp1->m_wxis;
14876 created1 = false;
14877 } else {
14878 PyErr_Clear(); // clear the failure of the wxPyConvert above
14879 arg1 = wxPyCBInputStream_create(obj0, false);
14880 if (arg1 == NULL) {
14881 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14882 SWIG_fail;
14883 }
14884 created1 = true;
14885 }
14886 }
14887 {
14888 PyThreadState* __tstate = wxPyBeginAllowThreads();
14889 result = (bool)wxImage::CanRead(*arg1);
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 {
14894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14895 }
14896 {
14897 if (created1) delete arg1;
14898 }
14899 return resultobj;
14900 fail:
14901 {
14902 if (created1) delete arg1;
14903 }
14904 return NULL;
14905 }
14906
14907
14908 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14909 PyObject *resultobj = 0;
14910 wxImage *arg1 = (wxImage *) 0 ;
14911 wxInputStream *arg2 = 0 ;
14912 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14913 int arg4 = (int) -1 ;
14914 bool result;
14915 void *argp1 = 0 ;
14916 int res1 = 0 ;
14917 wxPyInputStream *temp2 ;
14918 bool created2 ;
14919 long val3 ;
14920 int ecode3 = 0 ;
14921 int val4 ;
14922 int ecode4 = 0 ;
14923 PyObject * obj0 = 0 ;
14924 PyObject * obj1 = 0 ;
14925 PyObject * obj2 = 0 ;
14926 PyObject * obj3 = 0 ;
14927 char * kwnames[] = {
14928 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14929 };
14930
14931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14935 }
14936 arg1 = reinterpret_cast< wxImage * >(argp1);
14937 {
14938 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14939 arg2 = temp2->m_wxis;
14940 created2 = false;
14941 } else {
14942 PyErr_Clear(); // clear the failure of the wxPyConvert above
14943 arg2 = wxPyCBInputStream_create(obj1, false);
14944 if (arg2 == NULL) {
14945 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14946 SWIG_fail;
14947 }
14948 created2 = true;
14949 }
14950 }
14951 if (obj2) {
14952 ecode3 = SWIG_AsVal_long(obj2, &val3);
14953 if (!SWIG_IsOK(ecode3)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14955 }
14956 arg3 = static_cast< long >(val3);
14957 }
14958 if (obj3) {
14959 ecode4 = SWIG_AsVal_int(obj3, &val4);
14960 if (!SWIG_IsOK(ecode4)) {
14961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14962 }
14963 arg4 = static_cast< int >(val4);
14964 }
14965 {
14966 PyThreadState* __tstate = wxPyBeginAllowThreads();
14967 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14968 wxPyEndAllowThreads(__tstate);
14969 if (PyErr_Occurred()) SWIG_fail;
14970 }
14971 {
14972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14973 }
14974 {
14975 if (created2) delete arg2;
14976 }
14977 return resultobj;
14978 fail:
14979 {
14980 if (created2) delete arg2;
14981 }
14982 return NULL;
14983 }
14984
14985
14986 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14987 PyObject *resultobj = 0;
14988 wxImage *arg1 = (wxImage *) 0 ;
14989 wxInputStream *arg2 = 0 ;
14990 wxString *arg3 = 0 ;
14991 int arg4 = (int) -1 ;
14992 bool result;
14993 void *argp1 = 0 ;
14994 int res1 = 0 ;
14995 wxPyInputStream *temp2 ;
14996 bool created2 ;
14997 bool temp3 = false ;
14998 int val4 ;
14999 int ecode4 = 0 ;
15000 PyObject * obj0 = 0 ;
15001 PyObject * obj1 = 0 ;
15002 PyObject * obj2 = 0 ;
15003 PyObject * obj3 = 0 ;
15004 char * kwnames[] = {
15005 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15006 };
15007
15008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15012 }
15013 arg1 = reinterpret_cast< wxImage * >(argp1);
15014 {
15015 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15016 arg2 = temp2->m_wxis;
15017 created2 = false;
15018 } else {
15019 PyErr_Clear(); // clear the failure of the wxPyConvert above
15020 arg2 = wxPyCBInputStream_create(obj1, false);
15021 if (arg2 == NULL) {
15022 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15023 SWIG_fail;
15024 }
15025 created2 = true;
15026 }
15027 }
15028 {
15029 arg3 = wxString_in_helper(obj2);
15030 if (arg3 == NULL) SWIG_fail;
15031 temp3 = true;
15032 }
15033 if (obj3) {
15034 ecode4 = SWIG_AsVal_int(obj3, &val4);
15035 if (!SWIG_IsOK(ecode4)) {
15036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15037 }
15038 arg4 = static_cast< int >(val4);
15039 }
15040 {
15041 PyThreadState* __tstate = wxPyBeginAllowThreads();
15042 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 {
15047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15048 }
15049 {
15050 if (created2) delete arg2;
15051 }
15052 {
15053 if (temp3)
15054 delete arg3;
15055 }
15056 return resultobj;
15057 fail:
15058 {
15059 if (created2) delete arg2;
15060 }
15061 {
15062 if (temp3)
15063 delete arg3;
15064 }
15065 return NULL;
15066 }
15067
15068
15069 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15070 PyObject *resultobj = 0;
15071 wxImage *arg1 = (wxImage *) 0 ;
15072 bool result;
15073 void *argp1 = 0 ;
15074 int res1 = 0 ;
15075 PyObject *swig_obj[1] ;
15076
15077 if (!args) SWIG_fail;
15078 swig_obj[0] = args;
15079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15080 if (!SWIG_IsOK(res1)) {
15081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15082 }
15083 arg1 = reinterpret_cast< wxImage * >(argp1);
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (bool)(arg1)->Ok();
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 {
15091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15092 }
15093 return resultobj;
15094 fail:
15095 return NULL;
15096 }
15097
15098
15099 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15100 PyObject *resultobj = 0;
15101 wxImage *arg1 = (wxImage *) 0 ;
15102 int result;
15103 void *argp1 = 0 ;
15104 int res1 = 0 ;
15105 PyObject *swig_obj[1] ;
15106
15107 if (!args) SWIG_fail;
15108 swig_obj[0] = args;
15109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15110 if (!SWIG_IsOK(res1)) {
15111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15112 }
15113 arg1 = reinterpret_cast< wxImage * >(argp1);
15114 {
15115 PyThreadState* __tstate = wxPyBeginAllowThreads();
15116 result = (int)(arg1)->GetWidth();
15117 wxPyEndAllowThreads(__tstate);
15118 if (PyErr_Occurred()) SWIG_fail;
15119 }
15120 resultobj = SWIG_From_int(static_cast< int >(result));
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128 PyObject *resultobj = 0;
15129 wxImage *arg1 = (wxImage *) 0 ;
15130 int result;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 PyObject *swig_obj[1] ;
15134
15135 if (!args) SWIG_fail;
15136 swig_obj[0] = args;
15137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15138 if (!SWIG_IsOK(res1)) {
15139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15140 }
15141 arg1 = reinterpret_cast< wxImage * >(argp1);
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 result = (int)(arg1)->GetHeight();
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 resultobj = SWIG_From_int(static_cast< int >(result));
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15156 PyObject *resultobj = 0;
15157 wxImage *arg1 = (wxImage *) 0 ;
15158 wxSize result;
15159 void *argp1 = 0 ;
15160 int res1 = 0 ;
15161 PyObject *swig_obj[1] ;
15162
15163 if (!args) SWIG_fail;
15164 swig_obj[0] = args;
15165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15166 if (!SWIG_IsOK(res1)) {
15167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15168 }
15169 arg1 = reinterpret_cast< wxImage * >(argp1);
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = wxImage_GetSize(arg1);
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15184 PyObject *resultobj = 0;
15185 wxImage *arg1 = (wxImage *) 0 ;
15186 wxRect *arg2 = 0 ;
15187 SwigValueWrapper<wxImage > result;
15188 void *argp1 = 0 ;
15189 int res1 = 0 ;
15190 wxRect temp2 ;
15191 PyObject * obj0 = 0 ;
15192 PyObject * obj1 = 0 ;
15193 char * kwnames[] = {
15194 (char *) "self",(char *) "rect", NULL
15195 };
15196
15197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15199 if (!SWIG_IsOK(res1)) {
15200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15201 }
15202 arg1 = reinterpret_cast< wxImage * >(argp1);
15203 {
15204 arg2 = &temp2;
15205 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15206 }
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj = 0;
15222 wxImage *arg1 = (wxImage *) 0 ;
15223 wxSize *arg2 = 0 ;
15224 wxPoint *arg3 = 0 ;
15225 int arg4 = (int) -1 ;
15226 int arg5 = (int) -1 ;
15227 int arg6 = (int) -1 ;
15228 SwigValueWrapper<wxImage > result;
15229 void *argp1 = 0 ;
15230 int res1 = 0 ;
15231 wxSize temp2 ;
15232 wxPoint temp3 ;
15233 int val4 ;
15234 int ecode4 = 0 ;
15235 int val5 ;
15236 int ecode5 = 0 ;
15237 int val6 ;
15238 int ecode6 = 0 ;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 PyObject * obj2 = 0 ;
15242 PyObject * obj3 = 0 ;
15243 PyObject * obj4 = 0 ;
15244 PyObject * obj5 = 0 ;
15245 char * kwnames[] = {
15246 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15247 };
15248
15249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15251 if (!SWIG_IsOK(res1)) {
15252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15253 }
15254 arg1 = reinterpret_cast< wxImage * >(argp1);
15255 {
15256 arg2 = &temp2;
15257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15258 }
15259 {
15260 arg3 = &temp3;
15261 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15262 }
15263 if (obj3) {
15264 ecode4 = SWIG_AsVal_int(obj3, &val4);
15265 if (!SWIG_IsOK(ecode4)) {
15266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15267 }
15268 arg4 = static_cast< int >(val4);
15269 }
15270 if (obj4) {
15271 ecode5 = SWIG_AsVal_int(obj4, &val5);
15272 if (!SWIG_IsOK(ecode5)) {
15273 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15274 }
15275 arg5 = static_cast< int >(val5);
15276 }
15277 if (obj5) {
15278 ecode6 = SWIG_AsVal_int(obj5, &val6);
15279 if (!SWIG_IsOK(ecode6)) {
15280 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15281 }
15282 arg6 = static_cast< int >(val6);
15283 }
15284 {
15285 PyThreadState* __tstate = wxPyBeginAllowThreads();
15286 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15298 PyObject *resultobj = 0;
15299 wxImage *arg1 = (wxImage *) 0 ;
15300 SwigValueWrapper<wxImage > result;
15301 void *argp1 = 0 ;
15302 int res1 = 0 ;
15303 PyObject *swig_obj[1] ;
15304
15305 if (!args) SWIG_fail;
15306 swig_obj[0] = args;
15307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15308 if (!SWIG_IsOK(res1)) {
15309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15310 }
15311 arg1 = reinterpret_cast< wxImage * >(argp1);
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 result = (arg1)->Copy();
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj = 0;
15327 wxImage *arg1 = (wxImage *) 0 ;
15328 wxImage *arg2 = 0 ;
15329 int arg3 ;
15330 int arg4 ;
15331 void *argp1 = 0 ;
15332 int res1 = 0 ;
15333 void *argp2 = 0 ;
15334 int res2 = 0 ;
15335 int val3 ;
15336 int ecode3 = 0 ;
15337 int val4 ;
15338 int ecode4 = 0 ;
15339 PyObject * obj0 = 0 ;
15340 PyObject * obj1 = 0 ;
15341 PyObject * obj2 = 0 ;
15342 PyObject * obj3 = 0 ;
15343 char * kwnames[] = {
15344 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15345 };
15346
15347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15349 if (!SWIG_IsOK(res1)) {
15350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15351 }
15352 arg1 = reinterpret_cast< wxImage * >(argp1);
15353 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15354 if (!SWIG_IsOK(res2)) {
15355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15356 }
15357 if (!argp2) {
15358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15359 }
15360 arg2 = reinterpret_cast< wxImage * >(argp2);
15361 ecode3 = SWIG_AsVal_int(obj2, &val3);
15362 if (!SWIG_IsOK(ecode3)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15364 }
15365 arg3 = static_cast< int >(val3);
15366 ecode4 = SWIG_AsVal_int(obj3, &val4);
15367 if (!SWIG_IsOK(ecode4)) {
15368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15369 }
15370 arg4 = static_cast< int >(val4);
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 resultobj = SWIG_Py_Void();
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15385 PyObject *resultobj = 0;
15386 wxImage *arg1 = (wxImage *) 0 ;
15387 PyObject *result = 0 ;
15388 void *argp1 = 0 ;
15389 int res1 = 0 ;
15390 PyObject *swig_obj[1] ;
15391
15392 if (!args) SWIG_fail;
15393 swig_obj[0] = args;
15394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15395 if (!SWIG_IsOK(res1)) {
15396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15397 }
15398 arg1 = reinterpret_cast< wxImage * >(argp1);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (PyObject *)wxImage_GetData(arg1);
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = result;
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15413 PyObject *resultobj = 0;
15414 wxImage *arg1 = (wxImage *) 0 ;
15415 buffer arg2 ;
15416 int arg3 ;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 PyObject * obj0 = 0 ;
15420 PyObject * obj1 = 0 ;
15421 char * kwnames[] = {
15422 (char *) "self",(char *) "data", NULL
15423 };
15424
15425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15429 }
15430 arg1 = reinterpret_cast< wxImage * >(argp1);
15431 {
15432 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15433 }
15434 {
15435 PyThreadState* __tstate = wxPyBeginAllowThreads();
15436 wxImage_SetData(arg1,arg2,arg3);
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_Py_Void();
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15448 PyObject *resultobj = 0;
15449 wxImage *arg1 = (wxImage *) 0 ;
15450 PyObject *result = 0 ;
15451 void *argp1 = 0 ;
15452 int res1 = 0 ;
15453 PyObject *swig_obj[1] ;
15454
15455 if (!args) SWIG_fail;
15456 swig_obj[0] = args;
15457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15458 if (!SWIG_IsOK(res1)) {
15459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15460 }
15461 arg1 = reinterpret_cast< wxImage * >(argp1);
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15465 wxPyEndAllowThreads(__tstate);
15466 if (PyErr_Occurred()) SWIG_fail;
15467 }
15468 resultobj = result;
15469 return resultobj;
15470 fail:
15471 return NULL;
15472 }
15473
15474
15475 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15476 PyObject *resultobj = 0;
15477 wxImage *arg1 = (wxImage *) 0 ;
15478 buffer arg2 ;
15479 int arg3 ;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 PyObject * obj0 = 0 ;
15483 PyObject * obj1 = 0 ;
15484 char * kwnames[] = {
15485 (char *) "self",(char *) "data", NULL
15486 };
15487
15488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15490 if (!SWIG_IsOK(res1)) {
15491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15492 }
15493 arg1 = reinterpret_cast< wxImage * >(argp1);
15494 {
15495 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15496 }
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 wxImage_SetDataBuffer(arg1,arg2,arg3);
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 resultobj = SWIG_Py_Void();
15504 return resultobj;
15505 fail:
15506 return NULL;
15507 }
15508
15509
15510 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15511 PyObject *resultobj = 0;
15512 wxImage *arg1 = (wxImage *) 0 ;
15513 PyObject *result = 0 ;
15514 void *argp1 = 0 ;
15515 int res1 = 0 ;
15516 PyObject *swig_obj[1] ;
15517
15518 if (!args) SWIG_fail;
15519 swig_obj[0] = args;
15520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15521 if (!SWIG_IsOK(res1)) {
15522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15523 }
15524 arg1 = reinterpret_cast< wxImage * >(argp1);
15525 {
15526 PyThreadState* __tstate = wxPyBeginAllowThreads();
15527 result = (PyObject *)wxImage_GetAlphaData(arg1);
15528 wxPyEndAllowThreads(__tstate);
15529 if (PyErr_Occurred()) SWIG_fail;
15530 }
15531 resultobj = result;
15532 return resultobj;
15533 fail:
15534 return NULL;
15535 }
15536
15537
15538 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj = 0;
15540 wxImage *arg1 = (wxImage *) 0 ;
15541 buffer arg2 ;
15542 int arg3 ;
15543 void *argp1 = 0 ;
15544 int res1 = 0 ;
15545 PyObject * obj0 = 0 ;
15546 PyObject * obj1 = 0 ;
15547 char * kwnames[] = {
15548 (char *) "self",(char *) "alpha", NULL
15549 };
15550
15551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15553 if (!SWIG_IsOK(res1)) {
15554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15555 }
15556 arg1 = reinterpret_cast< wxImage * >(argp1);
15557 {
15558 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 wxImage_SetAlphaData(arg1,arg2,arg3);
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 resultobj = SWIG_Py_Void();
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15574 PyObject *resultobj = 0;
15575 wxImage *arg1 = (wxImage *) 0 ;
15576 PyObject *result = 0 ;
15577 void *argp1 = 0 ;
15578 int res1 = 0 ;
15579 PyObject *swig_obj[1] ;
15580
15581 if (!args) SWIG_fail;
15582 swig_obj[0] = args;
15583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15584 if (!SWIG_IsOK(res1)) {
15585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15586 }
15587 arg1 = reinterpret_cast< wxImage * >(argp1);
15588 {
15589 PyThreadState* __tstate = wxPyBeginAllowThreads();
15590 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15591 wxPyEndAllowThreads(__tstate);
15592 if (PyErr_Occurred()) SWIG_fail;
15593 }
15594 resultobj = result;
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15602 PyObject *resultobj = 0;
15603 wxImage *arg1 = (wxImage *) 0 ;
15604 buffer arg2 ;
15605 int arg3 ;
15606 void *argp1 = 0 ;
15607 int res1 = 0 ;
15608 PyObject * obj0 = 0 ;
15609 PyObject * obj1 = 0 ;
15610 char * kwnames[] = {
15611 (char *) "self",(char *) "alpha", NULL
15612 };
15613
15614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15618 }
15619 arg1 = reinterpret_cast< wxImage * >(argp1);
15620 {
15621 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15622 }
15623 {
15624 PyThreadState* __tstate = wxPyBeginAllowThreads();
15625 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15626 wxPyEndAllowThreads(__tstate);
15627 if (PyErr_Occurred()) SWIG_fail;
15628 }
15629 resultobj = SWIG_Py_Void();
15630 return resultobj;
15631 fail:
15632 return NULL;
15633 }
15634
15635
15636 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15637 PyObject *resultobj = 0;
15638 wxImage *arg1 = (wxImage *) 0 ;
15639 byte arg2 ;
15640 byte arg3 ;
15641 byte arg4 ;
15642 void *argp1 = 0 ;
15643 int res1 = 0 ;
15644 unsigned char val2 ;
15645 int ecode2 = 0 ;
15646 unsigned char val3 ;
15647 int ecode3 = 0 ;
15648 unsigned char val4 ;
15649 int ecode4 = 0 ;
15650 PyObject * obj0 = 0 ;
15651 PyObject * obj1 = 0 ;
15652 PyObject * obj2 = 0 ;
15653 PyObject * obj3 = 0 ;
15654 char * kwnames[] = {
15655 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15656 };
15657
15658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15660 if (!SWIG_IsOK(res1)) {
15661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15662 }
15663 arg1 = reinterpret_cast< wxImage * >(argp1);
15664 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15665 if (!SWIG_IsOK(ecode2)) {
15666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15667 }
15668 arg2 = static_cast< byte >(val2);
15669 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15670 if (!SWIG_IsOK(ecode3)) {
15671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15672 }
15673 arg3 = static_cast< byte >(val3);
15674 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15675 if (!SWIG_IsOK(ecode4)) {
15676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15677 }
15678 arg4 = static_cast< byte >(val4);
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 (arg1)->SetMaskColour(arg2,arg3,arg4);
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_Py_Void();
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15693 PyObject *resultobj = 0;
15694 wxImage *arg1 = (wxImage *) 0 ;
15695 byte *arg2 = (byte *) 0 ;
15696 byte *arg3 = (byte *) 0 ;
15697 byte *arg4 = (byte *) 0 ;
15698 void *argp1 = 0 ;
15699 int res1 = 0 ;
15700 byte temp2 ;
15701 int res2 = SWIG_TMPOBJ ;
15702 byte temp3 ;
15703 int res3 = SWIG_TMPOBJ ;
15704 byte temp4 ;
15705 int res4 = SWIG_TMPOBJ ;
15706 PyObject *swig_obj[1] ;
15707
15708 arg2 = &temp2;
15709 arg3 = &temp3;
15710 arg4 = &temp4;
15711 if (!args) SWIG_fail;
15712 swig_obj[0] = args;
15713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15714 if (!SWIG_IsOK(res1)) {
15715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15716 }
15717 arg1 = reinterpret_cast< wxImage * >(argp1);
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 resultobj = SWIG_Py_Void();
15725 if (SWIG_IsTmpObj(res2)) {
15726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15727 } else {
15728 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15730 }
15731 if (SWIG_IsTmpObj(res3)) {
15732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15733 } else {
15734 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15736 }
15737 if (SWIG_IsTmpObj(res4)) {
15738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15739 } else {
15740 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15742 }
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15750 PyObject *resultobj = 0;
15751 wxImage *arg1 = (wxImage *) 0 ;
15752 byte result;
15753 void *argp1 = 0 ;
15754 int res1 = 0 ;
15755 PyObject *swig_obj[1] ;
15756
15757 if (!args) SWIG_fail;
15758 swig_obj[0] = args;
15759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15760 if (!SWIG_IsOK(res1)) {
15761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15762 }
15763 arg1 = reinterpret_cast< wxImage * >(argp1);
15764 {
15765 PyThreadState* __tstate = wxPyBeginAllowThreads();
15766 result = (byte)(arg1)->GetMaskRed();
15767 wxPyEndAllowThreads(__tstate);
15768 if (PyErr_Occurred()) SWIG_fail;
15769 }
15770 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15778 PyObject *resultobj = 0;
15779 wxImage *arg1 = (wxImage *) 0 ;
15780 byte result;
15781 void *argp1 = 0 ;
15782 int res1 = 0 ;
15783 PyObject *swig_obj[1] ;
15784
15785 if (!args) SWIG_fail;
15786 swig_obj[0] = args;
15787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15788 if (!SWIG_IsOK(res1)) {
15789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15790 }
15791 arg1 = reinterpret_cast< wxImage * >(argp1);
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (byte)(arg1)->GetMaskGreen();
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15806 PyObject *resultobj = 0;
15807 wxImage *arg1 = (wxImage *) 0 ;
15808 byte result;
15809 void *argp1 = 0 ;
15810 int res1 = 0 ;
15811 PyObject *swig_obj[1] ;
15812
15813 if (!args) SWIG_fail;
15814 swig_obj[0] = args;
15815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15816 if (!SWIG_IsOK(res1)) {
15817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15818 }
15819 arg1 = reinterpret_cast< wxImage * >(argp1);
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (byte)(arg1)->GetMaskBlue();
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15827 return resultobj;
15828 fail:
15829 return NULL;
15830 }
15831
15832
15833 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15834 PyObject *resultobj = 0;
15835 wxImage *arg1 = (wxImage *) 0 ;
15836 bool arg2 = (bool) true ;
15837 void *argp1 = 0 ;
15838 int res1 = 0 ;
15839 bool val2 ;
15840 int ecode2 = 0 ;
15841 PyObject * obj0 = 0 ;
15842 PyObject * obj1 = 0 ;
15843 char * kwnames[] = {
15844 (char *) "self",(char *) "mask", NULL
15845 };
15846
15847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15849 if (!SWIG_IsOK(res1)) {
15850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15851 }
15852 arg1 = reinterpret_cast< wxImage * >(argp1);
15853 if (obj1) {
15854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15855 if (!SWIG_IsOK(ecode2)) {
15856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15857 }
15858 arg2 = static_cast< bool >(val2);
15859 }
15860 {
15861 PyThreadState* __tstate = wxPyBeginAllowThreads();
15862 (arg1)->SetMask(arg2);
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 resultobj = SWIG_Py_Void();
15867 return resultobj;
15868 fail:
15869 return NULL;
15870 }
15871
15872
15873 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15874 PyObject *resultobj = 0;
15875 wxImage *arg1 = (wxImage *) 0 ;
15876 bool result;
15877 void *argp1 = 0 ;
15878 int res1 = 0 ;
15879 PyObject *swig_obj[1] ;
15880
15881 if (!args) SWIG_fail;
15882 swig_obj[0] = args;
15883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15884 if (!SWIG_IsOK(res1)) {
15885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15886 }
15887 arg1 = reinterpret_cast< wxImage * >(argp1);
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 result = (bool)(arg1)->HasMask();
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 {
15895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15896 }
15897 return resultobj;
15898 fail:
15899 return NULL;
15900 }
15901
15902
15903 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15904 PyObject *resultobj = 0;
15905 wxImage *arg1 = (wxImage *) 0 ;
15906 double arg2 ;
15907 wxPoint *arg3 = 0 ;
15908 bool arg4 = (bool) true ;
15909 wxPoint *arg5 = (wxPoint *) NULL ;
15910 SwigValueWrapper<wxImage > result;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 double val2 ;
15914 int ecode2 = 0 ;
15915 wxPoint temp3 ;
15916 bool val4 ;
15917 int ecode4 = 0 ;
15918 void *argp5 = 0 ;
15919 int res5 = 0 ;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 PyObject * obj2 = 0 ;
15923 PyObject * obj3 = 0 ;
15924 PyObject * obj4 = 0 ;
15925 char * kwnames[] = {
15926 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15927 };
15928
15929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15931 if (!SWIG_IsOK(res1)) {
15932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15933 }
15934 arg1 = reinterpret_cast< wxImage * >(argp1);
15935 ecode2 = SWIG_AsVal_double(obj1, &val2);
15936 if (!SWIG_IsOK(ecode2)) {
15937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15938 }
15939 arg2 = static_cast< double >(val2);
15940 {
15941 arg3 = &temp3;
15942 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15943 }
15944 if (obj3) {
15945 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15946 if (!SWIG_IsOK(ecode4)) {
15947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15948 }
15949 arg4 = static_cast< bool >(val4);
15950 }
15951 if (obj4) {
15952 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15953 if (!SWIG_IsOK(res5)) {
15954 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15955 }
15956 arg5 = reinterpret_cast< wxPoint * >(argp5);
15957 }
15958 {
15959 PyThreadState* __tstate = wxPyBeginAllowThreads();
15960 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15961 wxPyEndAllowThreads(__tstate);
15962 if (PyErr_Occurred()) SWIG_fail;
15963 }
15964 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15965 return resultobj;
15966 fail:
15967 return NULL;
15968 }
15969
15970
15971 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj = 0;
15973 wxImage *arg1 = (wxImage *) 0 ;
15974 bool arg2 = (bool) true ;
15975 SwigValueWrapper<wxImage > result;
15976 void *argp1 = 0 ;
15977 int res1 = 0 ;
15978 bool val2 ;
15979 int ecode2 = 0 ;
15980 PyObject * obj0 = 0 ;
15981 PyObject * obj1 = 0 ;
15982 char * kwnames[] = {
15983 (char *) "self",(char *) "clockwise", NULL
15984 };
15985
15986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15988 if (!SWIG_IsOK(res1)) {
15989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15990 }
15991 arg1 = reinterpret_cast< wxImage * >(argp1);
15992 if (obj1) {
15993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15994 if (!SWIG_IsOK(ecode2)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15996 }
15997 arg2 = static_cast< bool >(val2);
15998 }
15999 {
16000 PyThreadState* __tstate = wxPyBeginAllowThreads();
16001 result = (arg1)->Rotate90(arg2);
16002 wxPyEndAllowThreads(__tstate);
16003 if (PyErr_Occurred()) SWIG_fail;
16004 }
16005 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16006 return resultobj;
16007 fail:
16008 return NULL;
16009 }
16010
16011
16012 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj = 0;
16014 wxImage *arg1 = (wxImage *) 0 ;
16015 bool arg2 = (bool) true ;
16016 SwigValueWrapper<wxImage > result;
16017 void *argp1 = 0 ;
16018 int res1 = 0 ;
16019 bool val2 ;
16020 int ecode2 = 0 ;
16021 PyObject * obj0 = 0 ;
16022 PyObject * obj1 = 0 ;
16023 char * kwnames[] = {
16024 (char *) "self",(char *) "horizontally", NULL
16025 };
16026
16027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16029 if (!SWIG_IsOK(res1)) {
16030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16031 }
16032 arg1 = reinterpret_cast< wxImage * >(argp1);
16033 if (obj1) {
16034 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16035 if (!SWIG_IsOK(ecode2)) {
16036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16037 }
16038 arg2 = static_cast< bool >(val2);
16039 }
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 result = (arg1)->Mirror(arg2);
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16047 return resultobj;
16048 fail:
16049 return NULL;
16050 }
16051
16052
16053 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16054 PyObject *resultobj = 0;
16055 wxImage *arg1 = (wxImage *) 0 ;
16056 byte arg2 ;
16057 byte arg3 ;
16058 byte arg4 ;
16059 byte arg5 ;
16060 byte arg6 ;
16061 byte arg7 ;
16062 void *argp1 = 0 ;
16063 int res1 = 0 ;
16064 unsigned char val2 ;
16065 int ecode2 = 0 ;
16066 unsigned char val3 ;
16067 int ecode3 = 0 ;
16068 unsigned char val4 ;
16069 int ecode4 = 0 ;
16070 unsigned char val5 ;
16071 int ecode5 = 0 ;
16072 unsigned char val6 ;
16073 int ecode6 = 0 ;
16074 unsigned char val7 ;
16075 int ecode7 = 0 ;
16076 PyObject * obj0 = 0 ;
16077 PyObject * obj1 = 0 ;
16078 PyObject * obj2 = 0 ;
16079 PyObject * obj3 = 0 ;
16080 PyObject * obj4 = 0 ;
16081 PyObject * obj5 = 0 ;
16082 PyObject * obj6 = 0 ;
16083 char * kwnames[] = {
16084 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16085 };
16086
16087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16089 if (!SWIG_IsOK(res1)) {
16090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16091 }
16092 arg1 = reinterpret_cast< wxImage * >(argp1);
16093 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16094 if (!SWIG_IsOK(ecode2)) {
16095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16096 }
16097 arg2 = static_cast< byte >(val2);
16098 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16099 if (!SWIG_IsOK(ecode3)) {
16100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16101 }
16102 arg3 = static_cast< byte >(val3);
16103 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16104 if (!SWIG_IsOK(ecode4)) {
16105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16106 }
16107 arg4 = static_cast< byte >(val4);
16108 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16109 if (!SWIG_IsOK(ecode5)) {
16110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16111 }
16112 arg5 = static_cast< byte >(val5);
16113 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16114 if (!SWIG_IsOK(ecode6)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16116 }
16117 arg6 = static_cast< byte >(val6);
16118 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16119 if (!SWIG_IsOK(ecode7)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16121 }
16122 arg7 = static_cast< byte >(val7);
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 resultobj = SWIG_Py_Void();
16130 return resultobj;
16131 fail:
16132 return NULL;
16133 }
16134
16135
16136 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16137 PyObject *resultobj = 0;
16138 wxImage *arg1 = (wxImage *) 0 ;
16139 double arg2 = (double) 0.299 ;
16140 double arg3 = (double) 0.587 ;
16141 double arg4 = (double) 0.114 ;
16142 SwigValueWrapper<wxImage > result;
16143 void *argp1 = 0 ;
16144 int res1 = 0 ;
16145 double val2 ;
16146 int ecode2 = 0 ;
16147 double val3 ;
16148 int ecode3 = 0 ;
16149 double val4 ;
16150 int ecode4 = 0 ;
16151 PyObject * obj0 = 0 ;
16152 PyObject * obj1 = 0 ;
16153 PyObject * obj2 = 0 ;
16154 PyObject * obj3 = 0 ;
16155 char * kwnames[] = {
16156 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16157 };
16158
16159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16163 }
16164 arg1 = reinterpret_cast< wxImage * >(argp1);
16165 if (obj1) {
16166 ecode2 = SWIG_AsVal_double(obj1, &val2);
16167 if (!SWIG_IsOK(ecode2)) {
16168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16169 }
16170 arg2 = static_cast< double >(val2);
16171 }
16172 if (obj2) {
16173 ecode3 = SWIG_AsVal_double(obj2, &val3);
16174 if (!SWIG_IsOK(ecode3)) {
16175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16176 }
16177 arg3 = static_cast< double >(val3);
16178 }
16179 if (obj3) {
16180 ecode4 = SWIG_AsVal_double(obj3, &val4);
16181 if (!SWIG_IsOK(ecode4)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16183 }
16184 arg4 = static_cast< double >(val4);
16185 }
16186 {
16187 PyThreadState* __tstate = wxPyBeginAllowThreads();
16188 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16189 wxPyEndAllowThreads(__tstate);
16190 if (PyErr_Occurred()) SWIG_fail;
16191 }
16192 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj = 0;
16201 wxImage *arg1 = (wxImage *) 0 ;
16202 byte arg2 ;
16203 byte arg3 ;
16204 byte arg4 ;
16205 SwigValueWrapper<wxImage > result;
16206 void *argp1 = 0 ;
16207 int res1 = 0 ;
16208 unsigned char val2 ;
16209 int ecode2 = 0 ;
16210 unsigned char val3 ;
16211 int ecode3 = 0 ;
16212 unsigned char val4 ;
16213 int ecode4 = 0 ;
16214 PyObject * obj0 = 0 ;
16215 PyObject * obj1 = 0 ;
16216 PyObject * obj2 = 0 ;
16217 PyObject * obj3 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16226 }
16227 arg1 = reinterpret_cast< wxImage * >(argp1);
16228 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16229 if (!SWIG_IsOK(ecode2)) {
16230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16231 }
16232 arg2 = static_cast< byte >(val2);
16233 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16234 if (!SWIG_IsOK(ecode3)) {
16235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16236 }
16237 arg3 = static_cast< byte >(val3);
16238 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16239 if (!SWIG_IsOK(ecode4)) {
16240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16241 }
16242 arg4 = static_cast< byte >(val4);
16243 {
16244 PyThreadState* __tstate = wxPyBeginAllowThreads();
16245 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16250 return resultobj;
16251 fail:
16252 return NULL;
16253 }
16254
16255
16256 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = 0;
16258 wxImage *arg1 = (wxImage *) 0 ;
16259 wxString *arg2 = 0 ;
16260 wxString *arg3 = 0 ;
16261 void *argp1 = 0 ;
16262 int res1 = 0 ;
16263 bool temp2 = false ;
16264 bool temp3 = false ;
16265 PyObject * obj0 = 0 ;
16266 PyObject * obj1 = 0 ;
16267 PyObject * obj2 = 0 ;
16268 char * kwnames[] = {
16269 (char *) "self",(char *) "name",(char *) "value", NULL
16270 };
16271
16272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16274 if (!SWIG_IsOK(res1)) {
16275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16276 }
16277 arg1 = reinterpret_cast< wxImage * >(argp1);
16278 {
16279 arg2 = wxString_in_helper(obj1);
16280 if (arg2 == NULL) SWIG_fail;
16281 temp2 = true;
16282 }
16283 {
16284 arg3 = wxString_in_helper(obj2);
16285 if (arg3 == NULL) SWIG_fail;
16286 temp3 = true;
16287 }
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16291 wxPyEndAllowThreads(__tstate);
16292 if (PyErr_Occurred()) SWIG_fail;
16293 }
16294 resultobj = SWIG_Py_Void();
16295 {
16296 if (temp2)
16297 delete arg2;
16298 }
16299 {
16300 if (temp3)
16301 delete arg3;
16302 }
16303 return resultobj;
16304 fail:
16305 {
16306 if (temp2)
16307 delete arg2;
16308 }
16309 {
16310 if (temp3)
16311 delete arg3;
16312 }
16313 return NULL;
16314 }
16315
16316
16317 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj = 0;
16319 wxImage *arg1 = (wxImage *) 0 ;
16320 wxString *arg2 = 0 ;
16321 int arg3 ;
16322 void *argp1 = 0 ;
16323 int res1 = 0 ;
16324 bool temp2 = false ;
16325 int val3 ;
16326 int ecode3 = 0 ;
16327 PyObject * obj0 = 0 ;
16328 PyObject * obj1 = 0 ;
16329 PyObject * obj2 = 0 ;
16330 char * kwnames[] = {
16331 (char *) "self",(char *) "name",(char *) "value", NULL
16332 };
16333
16334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16336 if (!SWIG_IsOK(res1)) {
16337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16338 }
16339 arg1 = reinterpret_cast< wxImage * >(argp1);
16340 {
16341 arg2 = wxString_in_helper(obj1);
16342 if (arg2 == NULL) SWIG_fail;
16343 temp2 = true;
16344 }
16345 ecode3 = SWIG_AsVal_int(obj2, &val3);
16346 if (!SWIG_IsOK(ecode3)) {
16347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16348 }
16349 arg3 = static_cast< int >(val3);
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 (arg1)->SetOption((wxString const &)*arg2,arg3);
16353 wxPyEndAllowThreads(__tstate);
16354 if (PyErr_Occurred()) SWIG_fail;
16355 }
16356 resultobj = SWIG_Py_Void();
16357 {
16358 if (temp2)
16359 delete arg2;
16360 }
16361 return resultobj;
16362 fail:
16363 {
16364 if (temp2)
16365 delete arg2;
16366 }
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 wxString *arg2 = 0 ;
16375 wxString result;
16376 void *argp1 = 0 ;
16377 int res1 = 0 ;
16378 bool temp2 = false ;
16379 PyObject * obj0 = 0 ;
16380 PyObject * obj1 = 0 ;
16381 char * kwnames[] = {
16382 (char *) "self",(char *) "name", NULL
16383 };
16384
16385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16387 if (!SWIG_IsOK(res1)) {
16388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16389 }
16390 arg1 = reinterpret_cast< wxImage * >(argp1);
16391 {
16392 arg2 = wxString_in_helper(obj1);
16393 if (arg2 == NULL) SWIG_fail;
16394 temp2 = true;
16395 }
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16399 wxPyEndAllowThreads(__tstate);
16400 if (PyErr_Occurred()) SWIG_fail;
16401 }
16402 {
16403 #if wxUSE_UNICODE
16404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16405 #else
16406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16407 #endif
16408 }
16409 {
16410 if (temp2)
16411 delete arg2;
16412 }
16413 return resultobj;
16414 fail:
16415 {
16416 if (temp2)
16417 delete arg2;
16418 }
16419 return NULL;
16420 }
16421
16422
16423 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj = 0;
16425 wxImage *arg1 = (wxImage *) 0 ;
16426 wxString *arg2 = 0 ;
16427 int result;
16428 void *argp1 = 0 ;
16429 int res1 = 0 ;
16430 bool temp2 = false ;
16431 PyObject * obj0 = 0 ;
16432 PyObject * obj1 = 0 ;
16433 char * kwnames[] = {
16434 (char *) "self",(char *) "name", NULL
16435 };
16436
16437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16439 if (!SWIG_IsOK(res1)) {
16440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16441 }
16442 arg1 = reinterpret_cast< wxImage * >(argp1);
16443 {
16444 arg2 = wxString_in_helper(obj1);
16445 if (arg2 == NULL) SWIG_fail;
16446 temp2 = true;
16447 }
16448 {
16449 PyThreadState* __tstate = wxPyBeginAllowThreads();
16450 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 resultobj = SWIG_From_int(static_cast< int >(result));
16455 {
16456 if (temp2)
16457 delete arg2;
16458 }
16459 return resultobj;
16460 fail:
16461 {
16462 if (temp2)
16463 delete arg2;
16464 }
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16470 PyObject *resultobj = 0;
16471 wxImage *arg1 = (wxImage *) 0 ;
16472 wxString *arg2 = 0 ;
16473 bool result;
16474 void *argp1 = 0 ;
16475 int res1 = 0 ;
16476 bool temp2 = false ;
16477 PyObject * obj0 = 0 ;
16478 PyObject * obj1 = 0 ;
16479 char * kwnames[] = {
16480 (char *) "self",(char *) "name", NULL
16481 };
16482
16483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16485 if (!SWIG_IsOK(res1)) {
16486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16487 }
16488 arg1 = reinterpret_cast< wxImage * >(argp1);
16489 {
16490 arg2 = wxString_in_helper(obj1);
16491 if (arg2 == NULL) SWIG_fail;
16492 temp2 = true;
16493 }
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 {
16501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16502 }
16503 {
16504 if (temp2)
16505 delete arg2;
16506 }
16507 return resultobj;
16508 fail:
16509 {
16510 if (temp2)
16511 delete arg2;
16512 }
16513 return NULL;
16514 }
16515
16516
16517 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj = 0;
16519 wxImage *arg1 = (wxImage *) 0 ;
16520 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16521 unsigned long result;
16522 void *argp1 = 0 ;
16523 int res1 = 0 ;
16524 unsigned long val2 ;
16525 int ecode2 = 0 ;
16526 PyObject * obj0 = 0 ;
16527 PyObject * obj1 = 0 ;
16528 char * kwnames[] = {
16529 (char *) "self",(char *) "stopafter", NULL
16530 };
16531
16532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16534 if (!SWIG_IsOK(res1)) {
16535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16536 }
16537 arg1 = reinterpret_cast< wxImage * >(argp1);
16538 if (obj1) {
16539 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16540 if (!SWIG_IsOK(ecode2)) {
16541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16542 }
16543 arg2 = static_cast< unsigned long >(val2);
16544 }
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 result = (unsigned long)(arg1)->CountColours(arg2);
16548 wxPyEndAllowThreads(__tstate);
16549 if (PyErr_Occurred()) SWIG_fail;
16550 }
16551 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj = 0;
16560 wxImage *arg1 = (wxImage *) 0 ;
16561 wxImageHistogram *arg2 = 0 ;
16562 unsigned long result;
16563 void *argp1 = 0 ;
16564 int res1 = 0 ;
16565 void *argp2 = 0 ;
16566 int res2 = 0 ;
16567 PyObject * obj0 = 0 ;
16568 PyObject * obj1 = 0 ;
16569 char * kwnames[] = {
16570 (char *) "self",(char *) "h", NULL
16571 };
16572
16573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16575 if (!SWIG_IsOK(res1)) {
16576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16577 }
16578 arg1 = reinterpret_cast< wxImage * >(argp1);
16579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16580 if (!SWIG_IsOK(res2)) {
16581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16582 }
16583 if (!argp2) {
16584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16585 }
16586 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj = 0;
16602 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16603 void *argp1 = 0 ;
16604 int res1 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 char * kwnames[] = {
16607 (char *) "handler", NULL
16608 };
16609
16610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16612 if (!SWIG_IsOK(res1)) {
16613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16614 }
16615 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 wxImage::AddHandler(arg1);
16619 wxPyEndAllowThreads(__tstate);
16620 if (PyErr_Occurred()) SWIG_fail;
16621 }
16622 resultobj = SWIG_Py_Void();
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj = 0;
16631 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16632 void *argp1 = 0 ;
16633 int res1 = 0 ;
16634 PyObject * obj0 = 0 ;
16635 char * kwnames[] = {
16636 (char *) "handler", NULL
16637 };
16638
16639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16641 if (!SWIG_IsOK(res1)) {
16642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16643 }
16644 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 wxImage::InsertHandler(arg1);
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 resultobj = SWIG_Py_Void();
16652 return resultobj;
16653 fail:
16654 return NULL;
16655 }
16656
16657
16658 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16659 PyObject *resultobj = 0;
16660 wxString *arg1 = 0 ;
16661 bool result;
16662 bool temp1 = false ;
16663 PyObject * obj0 = 0 ;
16664 char * kwnames[] = {
16665 (char *) "name", NULL
16666 };
16667
16668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16669 {
16670 arg1 = wxString_in_helper(obj0);
16671 if (arg1 == NULL) SWIG_fail;
16672 temp1 = true;
16673 }
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 {
16681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16682 }
16683 {
16684 if (temp1)
16685 delete arg1;
16686 }
16687 return resultobj;
16688 fail:
16689 {
16690 if (temp1)
16691 delete arg1;
16692 }
16693 return NULL;
16694 }
16695
16696
16697 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16698 PyObject *resultobj = 0;
16699 PyObject *result = 0 ;
16700
16701 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16702 {
16703 PyThreadState* __tstate = wxPyBeginAllowThreads();
16704 result = (PyObject *)wxImage_GetHandlers();
16705 wxPyEndAllowThreads(__tstate);
16706 if (PyErr_Occurred()) SWIG_fail;
16707 }
16708 resultobj = result;
16709 return resultobj;
16710 fail:
16711 return NULL;
16712 }
16713
16714
16715 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16716 PyObject *resultobj = 0;
16717 wxString result;
16718
16719 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16720 {
16721 PyThreadState* __tstate = wxPyBeginAllowThreads();
16722 result = wxImage::GetImageExtWildcard();
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 {
16727 #if wxUSE_UNICODE
16728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16729 #else
16730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16731 #endif
16732 }
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj = 0;
16741 wxImage *arg1 = (wxImage *) 0 ;
16742 int arg2 = (int) -1 ;
16743 wxBitmap result;
16744 void *argp1 = 0 ;
16745 int res1 = 0 ;
16746 int val2 ;
16747 int ecode2 = 0 ;
16748 PyObject * obj0 = 0 ;
16749 PyObject * obj1 = 0 ;
16750 char * kwnames[] = {
16751 (char *) "self",(char *) "depth", NULL
16752 };
16753
16754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16756 if (!SWIG_IsOK(res1)) {
16757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16758 }
16759 arg1 = reinterpret_cast< wxImage * >(argp1);
16760 if (obj1) {
16761 ecode2 = SWIG_AsVal_int(obj1, &val2);
16762 if (!SWIG_IsOK(ecode2)) {
16763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16764 }
16765 arg2 = static_cast< int >(val2);
16766 }
16767 {
16768 if (!wxPyCheckForApp()) SWIG_fail;
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = wxImage_ConvertToBitmap(arg1,arg2);
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj = 0;
16783 wxImage *arg1 = (wxImage *) 0 ;
16784 byte arg2 ;
16785 byte arg3 ;
16786 byte arg4 ;
16787 wxBitmap result;
16788 void *argp1 = 0 ;
16789 int res1 = 0 ;
16790 unsigned char val2 ;
16791 int ecode2 = 0 ;
16792 unsigned char val3 ;
16793 int ecode3 = 0 ;
16794 unsigned char val4 ;
16795 int ecode4 = 0 ;
16796 PyObject * obj0 = 0 ;
16797 PyObject * obj1 = 0 ;
16798 PyObject * obj2 = 0 ;
16799 PyObject * obj3 = 0 ;
16800 char * kwnames[] = {
16801 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16802 };
16803
16804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16806 if (!SWIG_IsOK(res1)) {
16807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16808 }
16809 arg1 = reinterpret_cast< wxImage * >(argp1);
16810 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16811 if (!SWIG_IsOK(ecode2)) {
16812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16813 }
16814 arg2 = static_cast< byte >(val2);
16815 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16816 if (!SWIG_IsOK(ecode3)) {
16817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16818 }
16819 arg3 = static_cast< byte >(val3);
16820 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16821 if (!SWIG_IsOK(ecode4)) {
16822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16823 }
16824 arg4 = static_cast< byte >(val4);
16825 {
16826 if (!wxPyCheckForApp()) SWIG_fail;
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj = 0;
16841 wxImage *arg1 = (wxImage *) 0 ;
16842 double arg2 ;
16843 void *argp1 = 0 ;
16844 int res1 = 0 ;
16845 double val2 ;
16846 int ecode2 = 0 ;
16847 PyObject * obj0 = 0 ;
16848 PyObject * obj1 = 0 ;
16849 char * kwnames[] = {
16850 (char *) "self",(char *) "angle", NULL
16851 };
16852
16853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16855 if (!SWIG_IsOK(res1)) {
16856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16857 }
16858 arg1 = reinterpret_cast< wxImage * >(argp1);
16859 ecode2 = SWIG_AsVal_double(obj1, &val2);
16860 if (!SWIG_IsOK(ecode2)) {
16861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16862 }
16863 arg2 = static_cast< double >(val2);
16864 {
16865 PyThreadState* __tstate = wxPyBeginAllowThreads();
16866 (arg1)->RotateHue(arg2);
16867 wxPyEndAllowThreads(__tstate);
16868 if (PyErr_Occurred()) SWIG_fail;
16869 }
16870 resultobj = SWIG_Py_Void();
16871 return resultobj;
16872 fail:
16873 return NULL;
16874 }
16875
16876
16877 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16878 PyObject *resultobj = 0;
16879 wxImage_RGBValue arg1 ;
16880 wxImage_HSVValue result;
16881 void *argp1 ;
16882 int res1 = 0 ;
16883 PyObject * obj0 = 0 ;
16884 char * kwnames[] = {
16885 (char *) "rgb", NULL
16886 };
16887
16888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16889 {
16890 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16893 }
16894 if (!argp1) {
16895 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16896 } else {
16897 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16898 arg1 = *temp;
16899 if (SWIG_IsNewObj(res1)) delete temp;
16900 }
16901 }
16902 {
16903 PyThreadState* __tstate = wxPyBeginAllowThreads();
16904 result = wxImage::RGBtoHSV(arg1);
16905 wxPyEndAllowThreads(__tstate);
16906 if (PyErr_Occurred()) SWIG_fail;
16907 }
16908 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16909 return resultobj;
16910 fail:
16911 return NULL;
16912 }
16913
16914
16915 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj = 0;
16917 wxImage_HSVValue arg1 ;
16918 wxImage_RGBValue result;
16919 void *argp1 ;
16920 int res1 = 0 ;
16921 PyObject * obj0 = 0 ;
16922 char * kwnames[] = {
16923 (char *) "hsv", NULL
16924 };
16925
16926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16927 {
16928 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16929 if (!SWIG_IsOK(res1)) {
16930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16931 }
16932 if (!argp1) {
16933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16934 } else {
16935 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16936 arg1 = *temp;
16937 if (SWIG_IsNewObj(res1)) delete temp;
16938 }
16939 }
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 result = wxImage::HSVtoRGB(arg1);
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16947 return resultobj;
16948 fail:
16949 return NULL;
16950 }
16951
16952
16953 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16954 PyObject *obj;
16955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16956 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16957 return SWIG_Py_Void();
16958 }
16959
16960 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16961 return SWIG_Python_InitShadowInstance(args);
16962 }
16963
16964 SWIGINTERN int NullImage_set(PyObject *) {
16965 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16966 return 1;
16967 }
16968
16969
16970 SWIGINTERN PyObject *NullImage_get(void) {
16971 PyObject *pyobj = 0;
16972
16973 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16974 return pyobj;
16975 }
16976
16977
16978 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16979 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16980 return 1;
16981 }
16982
16983
16984 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16985 PyObject *pyobj = 0;
16986
16987 {
16988 #if wxUSE_UNICODE
16989 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16990 #else
16991 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16992 #endif
16993 }
16994 return pyobj;
16995 }
16996
16997
16998 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16999 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17000 return 1;
17001 }
17002
17003
17004 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17005 PyObject *pyobj = 0;
17006
17007 {
17008 #if wxUSE_UNICODE
17009 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17010 #else
17011 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17012 #endif
17013 }
17014 return pyobj;
17015 }
17016
17017
17018 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17019 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17020 return 1;
17021 }
17022
17023
17024 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17025 PyObject *pyobj = 0;
17026
17027 {
17028 #if wxUSE_UNICODE
17029 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17030 #else
17031 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17032 #endif
17033 }
17034 return pyobj;
17035 }
17036
17037
17038 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17039 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17040 return 1;
17041 }
17042
17043
17044 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17045 PyObject *pyobj = 0;
17046
17047 {
17048 #if wxUSE_UNICODE
17049 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17050 #else
17051 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17052 #endif
17053 }
17054 return pyobj;
17055 }
17056
17057
17058 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17059 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17060 return 1;
17061 }
17062
17063
17064 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17065 PyObject *pyobj = 0;
17066
17067 {
17068 #if wxUSE_UNICODE
17069 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17070 #else
17071 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17072 #endif
17073 }
17074 return pyobj;
17075 }
17076
17077
17078 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17079 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17080 return 1;
17081 }
17082
17083
17084 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17085 PyObject *pyobj = 0;
17086
17087 {
17088 #if wxUSE_UNICODE
17089 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17090 #else
17091 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17092 #endif
17093 }
17094 return pyobj;
17095 }
17096
17097
17098 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17099 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17100 return 1;
17101 }
17102
17103
17104 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17105 PyObject *pyobj = 0;
17106
17107 {
17108 #if wxUSE_UNICODE
17109 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17110 #else
17111 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17112 #endif
17113 }
17114 return pyobj;
17115 }
17116
17117
17118 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17119 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17120 return 1;
17121 }
17122
17123
17124 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17125 PyObject *pyobj = 0;
17126
17127 {
17128 #if wxUSE_UNICODE
17129 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17130 #else
17131 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17132 #endif
17133 }
17134 return pyobj;
17135 }
17136
17137
17138 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17139 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17140 return 1;
17141 }
17142
17143
17144 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17145 PyObject *pyobj = 0;
17146
17147 {
17148 #if wxUSE_UNICODE
17149 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17150 #else
17151 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17152 #endif
17153 }
17154 return pyobj;
17155 }
17156
17157
17158 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17159 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17160 return 1;
17161 }
17162
17163
17164 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17165 PyObject *pyobj = 0;
17166
17167 {
17168 #if wxUSE_UNICODE
17169 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17170 #else
17171 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17172 #endif
17173 }
17174 return pyobj;
17175 }
17176
17177
17178 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17179 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17180 return 1;
17181 }
17182
17183
17184 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17185 PyObject *pyobj = 0;
17186
17187 {
17188 #if wxUSE_UNICODE
17189 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17190 #else
17191 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17192 #endif
17193 }
17194 return pyobj;
17195 }
17196
17197
17198 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17199 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17200 return 1;
17201 }
17202
17203
17204 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17205 PyObject *pyobj = 0;
17206
17207 {
17208 #if wxUSE_UNICODE
17209 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17210 #else
17211 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17212 #endif
17213 }
17214 return pyobj;
17215 }
17216
17217
17218 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17219 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17220 return 1;
17221 }
17222
17223
17224 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17225 PyObject *pyobj = 0;
17226
17227 {
17228 #if wxUSE_UNICODE
17229 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17230 #else
17231 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17232 #endif
17233 }
17234 return pyobj;
17235 }
17236
17237
17238 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17239 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17240 return 1;
17241 }
17242
17243
17244 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17245 PyObject *pyobj = 0;
17246
17247 {
17248 #if wxUSE_UNICODE
17249 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17250 #else
17251 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17252 #endif
17253 }
17254 return pyobj;
17255 }
17256
17257
17258 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17259 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17260 return 1;
17261 }
17262
17263
17264 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17265 PyObject *pyobj = 0;
17266
17267 {
17268 #if wxUSE_UNICODE
17269 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17270 #else
17271 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17272 #endif
17273 }
17274 return pyobj;
17275 }
17276
17277
17278 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279 PyObject *resultobj = 0;
17280 wxBMPHandler *result = 0 ;
17281
17282 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17283 {
17284 PyThreadState* __tstate = wxPyBeginAllowThreads();
17285 result = (wxBMPHandler *)new wxBMPHandler();
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 PyObject *obj;
17298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17299 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17300 return SWIG_Py_Void();
17301 }
17302
17303 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17304 return SWIG_Python_InitShadowInstance(args);
17305 }
17306
17307 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17308 PyObject *resultobj = 0;
17309 wxICOHandler *result = 0 ;
17310
17311 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (wxICOHandler *)new wxICOHandler();
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17319 return resultobj;
17320 fail:
17321 return NULL;
17322 }
17323
17324
17325 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 PyObject *obj;
17327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17328 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17329 return SWIG_Py_Void();
17330 }
17331
17332 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 return SWIG_Python_InitShadowInstance(args);
17334 }
17335
17336 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17337 PyObject *resultobj = 0;
17338 wxCURHandler *result = 0 ;
17339
17340 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (wxCURHandler *)new wxCURHandler();
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17348 return resultobj;
17349 fail:
17350 return NULL;
17351 }
17352
17353
17354 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 PyObject *obj;
17356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17357 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17358 return SWIG_Py_Void();
17359 }
17360
17361 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17362 return SWIG_Python_InitShadowInstance(args);
17363 }
17364
17365 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17366 PyObject *resultobj = 0;
17367 wxANIHandler *result = 0 ;
17368
17369 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17370 {
17371 PyThreadState* __tstate = wxPyBeginAllowThreads();
17372 result = (wxANIHandler *)new wxANIHandler();
17373 wxPyEndAllowThreads(__tstate);
17374 if (PyErr_Occurred()) SWIG_fail;
17375 }
17376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17377 return resultobj;
17378 fail:
17379 return NULL;
17380 }
17381
17382
17383 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17384 PyObject *obj;
17385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17386 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17387 return SWIG_Py_Void();
17388 }
17389
17390 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17391 return SWIG_Python_InitShadowInstance(args);
17392 }
17393
17394 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17395 PyObject *resultobj = 0;
17396 wxPNGHandler *result = 0 ;
17397
17398 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17399 {
17400 PyThreadState* __tstate = wxPyBeginAllowThreads();
17401 result = (wxPNGHandler *)new wxPNGHandler();
17402 wxPyEndAllowThreads(__tstate);
17403 if (PyErr_Occurred()) SWIG_fail;
17404 }
17405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17406 return resultobj;
17407 fail:
17408 return NULL;
17409 }
17410
17411
17412 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17413 PyObject *obj;
17414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17415 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17416 return SWIG_Py_Void();
17417 }
17418
17419 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17420 return SWIG_Python_InitShadowInstance(args);
17421 }
17422
17423 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17424 PyObject *resultobj = 0;
17425 wxGIFHandler *result = 0 ;
17426
17427 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (wxGIFHandler *)new wxGIFHandler();
17431 wxPyEndAllowThreads(__tstate);
17432 if (PyErr_Occurred()) SWIG_fail;
17433 }
17434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17435 return resultobj;
17436 fail:
17437 return NULL;
17438 }
17439
17440
17441 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17442 PyObject *obj;
17443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17444 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17445 return SWIG_Py_Void();
17446 }
17447
17448 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17449 return SWIG_Python_InitShadowInstance(args);
17450 }
17451
17452 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17453 PyObject *resultobj = 0;
17454 wxPCXHandler *result = 0 ;
17455
17456 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17457 {
17458 PyThreadState* __tstate = wxPyBeginAllowThreads();
17459 result = (wxPCXHandler *)new wxPCXHandler();
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17464 return resultobj;
17465 fail:
17466 return NULL;
17467 }
17468
17469
17470 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17471 PyObject *obj;
17472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17473 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17474 return SWIG_Py_Void();
17475 }
17476
17477 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17478 return SWIG_Python_InitShadowInstance(args);
17479 }
17480
17481 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17482 PyObject *resultobj = 0;
17483 wxJPEGHandler *result = 0 ;
17484
17485 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 result = (wxJPEGHandler *)new wxJPEGHandler();
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17500 PyObject *obj;
17501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17502 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17503 return SWIG_Py_Void();
17504 }
17505
17506 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17507 return SWIG_Python_InitShadowInstance(args);
17508 }
17509
17510 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17511 PyObject *resultobj = 0;
17512 wxPNMHandler *result = 0 ;
17513
17514 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17515 {
17516 PyThreadState* __tstate = wxPyBeginAllowThreads();
17517 result = (wxPNMHandler *)new wxPNMHandler();
17518 wxPyEndAllowThreads(__tstate);
17519 if (PyErr_Occurred()) SWIG_fail;
17520 }
17521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17522 return resultobj;
17523 fail:
17524 return NULL;
17525 }
17526
17527
17528 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17529 PyObject *obj;
17530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17531 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17532 return SWIG_Py_Void();
17533 }
17534
17535 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17536 return SWIG_Python_InitShadowInstance(args);
17537 }
17538
17539 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17540 PyObject *resultobj = 0;
17541 wxXPMHandler *result = 0 ;
17542
17543 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17544 {
17545 PyThreadState* __tstate = wxPyBeginAllowThreads();
17546 result = (wxXPMHandler *)new wxXPMHandler();
17547 wxPyEndAllowThreads(__tstate);
17548 if (PyErr_Occurred()) SWIG_fail;
17549 }
17550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17551 return resultobj;
17552 fail:
17553 return NULL;
17554 }
17555
17556
17557 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17558 PyObject *obj;
17559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17560 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17561 return SWIG_Py_Void();
17562 }
17563
17564 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17565 return SWIG_Python_InitShadowInstance(args);
17566 }
17567
17568 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17569 PyObject *resultobj = 0;
17570 wxTIFFHandler *result = 0 ;
17571
17572 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17573 {
17574 PyThreadState* __tstate = wxPyBeginAllowThreads();
17575 result = (wxTIFFHandler *)new wxTIFFHandler();
17576 wxPyEndAllowThreads(__tstate);
17577 if (PyErr_Occurred()) SWIG_fail;
17578 }
17579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17580 return resultobj;
17581 fail:
17582 return NULL;
17583 }
17584
17585
17586 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17587 PyObject *obj;
17588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17589 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17590 return SWIG_Py_Void();
17591 }
17592
17593 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17594 return SWIG_Python_InitShadowInstance(args);
17595 }
17596
17597 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj = 0;
17599 wxImage *arg1 = 0 ;
17600 wxImage *arg2 = 0 ;
17601 int arg3 = (int) 236 ;
17602 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17603 bool result;
17604 void *argp1 = 0 ;
17605 int res1 = 0 ;
17606 void *argp2 = 0 ;
17607 int res2 = 0 ;
17608 int val3 ;
17609 int ecode3 = 0 ;
17610 int val4 ;
17611 int ecode4 = 0 ;
17612 PyObject * obj0 = 0 ;
17613 PyObject * obj1 = 0 ;
17614 PyObject * obj2 = 0 ;
17615 PyObject * obj3 = 0 ;
17616 char * kwnames[] = {
17617 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17618 };
17619
17620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17621 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17622 if (!SWIG_IsOK(res1)) {
17623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17624 }
17625 if (!argp1) {
17626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17627 }
17628 arg1 = reinterpret_cast< wxImage * >(argp1);
17629 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17630 if (!SWIG_IsOK(res2)) {
17631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17632 }
17633 if (!argp2) {
17634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17635 }
17636 arg2 = reinterpret_cast< wxImage * >(argp2);
17637 if (obj2) {
17638 ecode3 = SWIG_AsVal_int(obj2, &val3);
17639 if (!SWIG_IsOK(ecode3)) {
17640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17641 }
17642 arg3 = static_cast< int >(val3);
17643 }
17644 if (obj3) {
17645 ecode4 = SWIG_AsVal_int(obj3, &val4);
17646 if (!SWIG_IsOK(ecode4)) {
17647 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17648 }
17649 arg4 = static_cast< int >(val4);
17650 }
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 {
17658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17659 }
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17667 PyObject *obj;
17668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17669 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17670 return SWIG_Py_Void();
17671 }
17672
17673 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17674 PyObject *resultobj = 0;
17675 wxEvtHandler *result = 0 ;
17676
17677 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (wxEvtHandler *)new wxEvtHandler();
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17685 return resultobj;
17686 fail:
17687 return NULL;
17688 }
17689
17690
17691 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17692 PyObject *resultobj = 0;
17693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17694 wxEvtHandler *result = 0 ;
17695 void *argp1 = 0 ;
17696 int res1 = 0 ;
17697 PyObject *swig_obj[1] ;
17698
17699 if (!args) SWIG_fail;
17700 swig_obj[0] = args;
17701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17702 if (!SWIG_IsOK(res1)) {
17703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17704 }
17705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17706 {
17707 PyThreadState* __tstate = wxPyBeginAllowThreads();
17708 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 {
17713 resultobj = wxPyMake_wxObject(result, 0);
17714 }
17715 return resultobj;
17716 fail:
17717 return NULL;
17718 }
17719
17720
17721 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17722 PyObject *resultobj = 0;
17723 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17724 wxEvtHandler *result = 0 ;
17725 void *argp1 = 0 ;
17726 int res1 = 0 ;
17727 PyObject *swig_obj[1] ;
17728
17729 if (!args) SWIG_fail;
17730 swig_obj[0] = args;
17731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17732 if (!SWIG_IsOK(res1)) {
17733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17734 }
17735 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = wxPyMake_wxObject(result, 0);
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj = 0;
17753 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17754 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 void *argp2 = 0 ;
17758 int res2 = 0 ;
17759 PyObject * obj0 = 0 ;
17760 PyObject * obj1 = 0 ;
17761 char * kwnames[] = {
17762 (char *) "self",(char *) "handler", NULL
17763 };
17764
17765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17767 if (!SWIG_IsOK(res1)) {
17768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17769 }
17770 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17772 if (!SWIG_IsOK(res2)) {
17773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17774 }
17775 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17776 {
17777 PyThreadState* __tstate = wxPyBeginAllowThreads();
17778 (arg1)->SetNextHandler(arg2);
17779 wxPyEndAllowThreads(__tstate);
17780 if (PyErr_Occurred()) SWIG_fail;
17781 }
17782 resultobj = SWIG_Py_Void();
17783 return resultobj;
17784 fail:
17785 return NULL;
17786 }
17787
17788
17789 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17790 PyObject *resultobj = 0;
17791 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17792 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17793 void *argp1 = 0 ;
17794 int res1 = 0 ;
17795 void *argp2 = 0 ;
17796 int res2 = 0 ;
17797 PyObject * obj0 = 0 ;
17798 PyObject * obj1 = 0 ;
17799 char * kwnames[] = {
17800 (char *) "self",(char *) "handler", NULL
17801 };
17802
17803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17805 if (!SWIG_IsOK(res1)) {
17806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17807 }
17808 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17810 if (!SWIG_IsOK(res2)) {
17811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17812 }
17813 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 (arg1)->SetPreviousHandler(arg2);
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 resultobj = SWIG_Py_Void();
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17828 PyObject *resultobj = 0;
17829 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17830 bool result;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 PyObject *swig_obj[1] ;
17834
17835 if (!args) SWIG_fail;
17836 swig_obj[0] = args;
17837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17838 if (!SWIG_IsOK(res1)) {
17839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17840 }
17841 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (bool)(arg1)->GetEvtHandlerEnabled();
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17850 }
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17858 PyObject *resultobj = 0;
17859 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17860 bool arg2 ;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 bool val2 ;
17864 int ecode2 = 0 ;
17865 PyObject * obj0 = 0 ;
17866 PyObject * obj1 = 0 ;
17867 char * kwnames[] = {
17868 (char *) "self",(char *) "enabled", NULL
17869 };
17870
17871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17873 if (!SWIG_IsOK(res1)) {
17874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17875 }
17876 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17878 if (!SWIG_IsOK(ecode2)) {
17879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17880 }
17881 arg2 = static_cast< bool >(val2);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 (arg1)->SetEvtHandlerEnabled(arg2);
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 resultobj = SWIG_Py_Void();
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj = 0;
17897 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17898 wxEvent *arg2 = 0 ;
17899 bool result;
17900 void *argp1 = 0 ;
17901 int res1 = 0 ;
17902 void *argp2 = 0 ;
17903 int res2 = 0 ;
17904 PyObject * obj0 = 0 ;
17905 PyObject * obj1 = 0 ;
17906 char * kwnames[] = {
17907 (char *) "self",(char *) "event", NULL
17908 };
17909
17910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17912 if (!SWIG_IsOK(res1)) {
17913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17914 }
17915 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17917 if (!SWIG_IsOK(res2)) {
17918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17919 }
17920 if (!argp2) {
17921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17922 }
17923 arg2 = reinterpret_cast< wxEvent * >(argp2);
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 result = (bool)(arg1)->ProcessEvent(*arg2);
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj = 0;
17941 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17942 wxEvent *arg2 = 0 ;
17943 void *argp1 = 0 ;
17944 int res1 = 0 ;
17945 void *argp2 = 0 ;
17946 int res2 = 0 ;
17947 PyObject * obj0 = 0 ;
17948 PyObject * obj1 = 0 ;
17949 char * kwnames[] = {
17950 (char *) "self",(char *) "event", NULL
17951 };
17952
17953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17955 if (!SWIG_IsOK(res1)) {
17956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17957 }
17958 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17960 if (!SWIG_IsOK(res2)) {
17961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17962 }
17963 if (!argp2) {
17964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17965 }
17966 arg2 = reinterpret_cast< wxEvent * >(argp2);
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 (arg1)->AddPendingEvent(*arg2);
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 resultobj = SWIG_Py_Void();
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17981 PyObject *resultobj = 0;
17982 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17983 void *argp1 = 0 ;
17984 int res1 = 0 ;
17985 PyObject *swig_obj[1] ;
17986
17987 if (!args) SWIG_fail;
17988 swig_obj[0] = args;
17989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17990 if (!SWIG_IsOK(res1)) {
17991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17992 }
17993 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17994 {
17995 PyThreadState* __tstate = wxPyBeginAllowThreads();
17996 (arg1)->ProcessPendingEvents();
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 resultobj = SWIG_Py_Void();
18001 return resultobj;
18002 fail:
18003 return NULL;
18004 }
18005
18006
18007 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18008 PyObject *resultobj = 0;
18009 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18010 int arg2 ;
18011 int arg3 ;
18012 int arg4 ;
18013 PyObject *arg5 = (PyObject *) 0 ;
18014 void *argp1 = 0 ;
18015 int res1 = 0 ;
18016 int val2 ;
18017 int ecode2 = 0 ;
18018 int val3 ;
18019 int ecode3 = 0 ;
18020 int val4 ;
18021 int ecode4 = 0 ;
18022 PyObject * obj0 = 0 ;
18023 PyObject * obj1 = 0 ;
18024 PyObject * obj2 = 0 ;
18025 PyObject * obj3 = 0 ;
18026 PyObject * obj4 = 0 ;
18027 char * kwnames[] = {
18028 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18029 };
18030
18031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18035 }
18036 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18037 ecode2 = SWIG_AsVal_int(obj1, &val2);
18038 if (!SWIG_IsOK(ecode2)) {
18039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18040 }
18041 arg2 = static_cast< int >(val2);
18042 ecode3 = SWIG_AsVal_int(obj2, &val3);
18043 if (!SWIG_IsOK(ecode3)) {
18044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18045 }
18046 arg3 = static_cast< int >(val3);
18047 ecode4 = SWIG_AsVal_int(obj3, &val4);
18048 if (!SWIG_IsOK(ecode4)) {
18049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18050 }
18051 arg4 = static_cast< int >(val4);
18052 arg5 = obj4;
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 resultobj = SWIG_Py_Void();
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18067 PyObject *resultobj = 0;
18068 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18069 int arg2 ;
18070 int arg3 = (int) -1 ;
18071 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18072 bool result;
18073 void *argp1 = 0 ;
18074 int res1 = 0 ;
18075 int val2 ;
18076 int ecode2 = 0 ;
18077 int val3 ;
18078 int ecode3 = 0 ;
18079 int val4 ;
18080 int ecode4 = 0 ;
18081 PyObject * obj0 = 0 ;
18082 PyObject * obj1 = 0 ;
18083 PyObject * obj2 = 0 ;
18084 PyObject * obj3 = 0 ;
18085 char * kwnames[] = {
18086 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18087 };
18088
18089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18091 if (!SWIG_IsOK(res1)) {
18092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18093 }
18094 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18095 ecode2 = SWIG_AsVal_int(obj1, &val2);
18096 if (!SWIG_IsOK(ecode2)) {
18097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18098 }
18099 arg2 = static_cast< int >(val2);
18100 if (obj2) {
18101 ecode3 = SWIG_AsVal_int(obj2, &val3);
18102 if (!SWIG_IsOK(ecode3)) {
18103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18104 }
18105 arg3 = static_cast< int >(val3);
18106 }
18107 if (obj3) {
18108 ecode4 = SWIG_AsVal_int(obj3, &val4);
18109 if (!SWIG_IsOK(ecode4)) {
18110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18111 }
18112 arg4 = static_cast< wxEventType >(val4);
18113 }
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18117 wxPyEndAllowThreads(__tstate);
18118 if (PyErr_Occurred()) SWIG_fail;
18119 }
18120 {
18121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18122 }
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18130 PyObject *resultobj = 0;
18131 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18132 PyObject *arg2 = (PyObject *) 0 ;
18133 bool arg3 = (bool) true ;
18134 void *argp1 = 0 ;
18135 int res1 = 0 ;
18136 bool val3 ;
18137 int ecode3 = 0 ;
18138 PyObject * obj0 = 0 ;
18139 PyObject * obj1 = 0 ;
18140 PyObject * obj2 = 0 ;
18141 char * kwnames[] = {
18142 (char *) "self",(char *) "_self",(char *) "incref", NULL
18143 };
18144
18145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18147 if (!SWIG_IsOK(res1)) {
18148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18149 }
18150 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18151 arg2 = obj1;
18152 if (obj2) {
18153 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18154 if (!SWIG_IsOK(ecode3)) {
18155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18156 }
18157 arg3 = static_cast< bool >(val3);
18158 }
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 resultobj = SWIG_Py_Void();
18166 return resultobj;
18167 fail:
18168 return NULL;
18169 }
18170
18171
18172 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18173 PyObject *obj;
18174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18175 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18176 return SWIG_Py_Void();
18177 }
18178
18179 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18180 return SWIG_Python_InitShadowInstance(args);
18181 }
18182
18183 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18184 PyObject *resultobj = 0;
18185 wxEventType result;
18186
18187 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (wxEventType)wxNewEventType();
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 resultobj = SWIG_From_int(static_cast< int >(result));
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18202 PyObject *resultobj = 0;
18203 wxEvent *arg1 = (wxEvent *) 0 ;
18204 void *argp1 = 0 ;
18205 int res1 = 0 ;
18206 PyObject *swig_obj[1] ;
18207
18208 if (!args) SWIG_fail;
18209 swig_obj[0] = args;
18210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18211 if (!SWIG_IsOK(res1)) {
18212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18213 }
18214 arg1 = reinterpret_cast< wxEvent * >(argp1);
18215 {
18216 PyThreadState* __tstate = wxPyBeginAllowThreads();
18217 delete arg1;
18218
18219 wxPyEndAllowThreads(__tstate);
18220 if (PyErr_Occurred()) SWIG_fail;
18221 }
18222 resultobj = SWIG_Py_Void();
18223 return resultobj;
18224 fail:
18225 return NULL;
18226 }
18227
18228
18229 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18230 PyObject *resultobj = 0;
18231 wxEvent *arg1 = (wxEvent *) 0 ;
18232 wxEventType arg2 ;
18233 void *argp1 = 0 ;
18234 int res1 = 0 ;
18235 int val2 ;
18236 int ecode2 = 0 ;
18237 PyObject * obj0 = 0 ;
18238 PyObject * obj1 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "typ", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvent * >(argp1);
18249 ecode2 = SWIG_AsVal_int(obj1, &val2);
18250 if (!SWIG_IsOK(ecode2)) {
18251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18252 }
18253 arg2 = static_cast< wxEventType >(val2);
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 (arg1)->SetEventType(arg2);
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_Py_Void();
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxEvent *arg1 = (wxEvent *) 0 ;
18270 wxEventType result;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 PyObject *swig_obj[1] ;
18274
18275 if (!args) SWIG_fail;
18276 swig_obj[0] = args;
18277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18278 if (!SWIG_IsOK(res1)) {
18279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18280 }
18281 arg1 = reinterpret_cast< wxEvent * >(argp1);
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 resultobj = SWIG_From_int(static_cast< int >(result));
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18296 PyObject *resultobj = 0;
18297 wxEvent *arg1 = (wxEvent *) 0 ;
18298 wxObject *result = 0 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 PyObject *swig_obj[1] ;
18302
18303 if (!args) SWIG_fail;
18304 swig_obj[0] = args;
18305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18306 if (!SWIG_IsOK(res1)) {
18307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18308 }
18309 arg1 = reinterpret_cast< wxEvent * >(argp1);
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = wxPyMake_wxObject(result, (bool)0);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj = 0;
18327 wxEvent *arg1 = (wxEvent *) 0 ;
18328 wxObject *arg2 = (wxObject *) 0 ;
18329 void *argp1 = 0 ;
18330 int res1 = 0 ;
18331 void *argp2 = 0 ;
18332 int res2 = 0 ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 char * kwnames[] = {
18336 (char *) "self",(char *) "obj", NULL
18337 };
18338
18339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18343 }
18344 arg1 = reinterpret_cast< wxEvent * >(argp1);
18345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18346 if (!SWIG_IsOK(res2)) {
18347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18348 }
18349 arg2 = reinterpret_cast< wxObject * >(argp2);
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 (arg1)->SetEventObject(arg2);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_Py_Void();
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18364 PyObject *resultobj = 0;
18365 wxEvent *arg1 = (wxEvent *) 0 ;
18366 long result;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 PyObject *swig_obj[1] ;
18370
18371 if (!args) SWIG_fail;
18372 swig_obj[0] = args;
18373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18374 if (!SWIG_IsOK(res1)) {
18375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18376 }
18377 arg1 = reinterpret_cast< wxEvent * >(argp1);
18378 {
18379 PyThreadState* __tstate = wxPyBeginAllowThreads();
18380 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 resultobj = SWIG_From_long(static_cast< long >(result));
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18392 PyObject *resultobj = 0;
18393 wxEvent *arg1 = (wxEvent *) 0 ;
18394 long arg2 = (long) 0 ;
18395 void *argp1 = 0 ;
18396 int res1 = 0 ;
18397 long val2 ;
18398 int ecode2 = 0 ;
18399 PyObject * obj0 = 0 ;
18400 PyObject * obj1 = 0 ;
18401 char * kwnames[] = {
18402 (char *) "self",(char *) "ts", NULL
18403 };
18404
18405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18407 if (!SWIG_IsOK(res1)) {
18408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18409 }
18410 arg1 = reinterpret_cast< wxEvent * >(argp1);
18411 if (obj1) {
18412 ecode2 = SWIG_AsVal_long(obj1, &val2);
18413 if (!SWIG_IsOK(ecode2)) {
18414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18415 }
18416 arg2 = static_cast< long >(val2);
18417 }
18418 {
18419 PyThreadState* __tstate = wxPyBeginAllowThreads();
18420 (arg1)->SetTimestamp(arg2);
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 resultobj = SWIG_Py_Void();
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18432 PyObject *resultobj = 0;
18433 wxEvent *arg1 = (wxEvent *) 0 ;
18434 int result;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 PyObject *swig_obj[1] ;
18438
18439 if (!args) SWIG_fail;
18440 swig_obj[0] = args;
18441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = (int)((wxEvent const *)arg1)->GetId();
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 resultobj = SWIG_From_int(static_cast< int >(result));
18453 return resultobj;
18454 fail:
18455 return NULL;
18456 }
18457
18458
18459 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj = 0;
18461 wxEvent *arg1 = (wxEvent *) 0 ;
18462 int arg2 ;
18463 void *argp1 = 0 ;
18464 int res1 = 0 ;
18465 int val2 ;
18466 int ecode2 = 0 ;
18467 PyObject * obj0 = 0 ;
18468 PyObject * obj1 = 0 ;
18469 char * kwnames[] = {
18470 (char *) "self",(char *) "Id", NULL
18471 };
18472
18473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18475 if (!SWIG_IsOK(res1)) {
18476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18477 }
18478 arg1 = reinterpret_cast< wxEvent * >(argp1);
18479 ecode2 = SWIG_AsVal_int(obj1, &val2);
18480 if (!SWIG_IsOK(ecode2)) {
18481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18482 }
18483 arg2 = static_cast< int >(val2);
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 (arg1)->SetId(arg2);
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 resultobj = SWIG_Py_Void();
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18498 PyObject *resultobj = 0;
18499 wxEvent *arg1 = (wxEvent *) 0 ;
18500 bool result;
18501 void *argp1 = 0 ;
18502 int res1 = 0 ;
18503 PyObject *swig_obj[1] ;
18504
18505 if (!args) SWIG_fail;
18506 swig_obj[0] = args;
18507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18508 if (!SWIG_IsOK(res1)) {
18509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18510 }
18511 arg1 = reinterpret_cast< wxEvent * >(argp1);
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 {
18519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj = 0;
18529 wxEvent *arg1 = (wxEvent *) 0 ;
18530 bool arg2 = (bool) true ;
18531 void *argp1 = 0 ;
18532 int res1 = 0 ;
18533 bool val2 ;
18534 int ecode2 = 0 ;
18535 PyObject * obj0 = 0 ;
18536 PyObject * obj1 = 0 ;
18537 char * kwnames[] = {
18538 (char *) "self",(char *) "skip", NULL
18539 };
18540
18541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18543 if (!SWIG_IsOK(res1)) {
18544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18545 }
18546 arg1 = reinterpret_cast< wxEvent * >(argp1);
18547 if (obj1) {
18548 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18549 if (!SWIG_IsOK(ecode2)) {
18550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18551 }
18552 arg2 = static_cast< bool >(val2);
18553 }
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 (arg1)->Skip(arg2);
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 resultobj = SWIG_Py_Void();
18561 return resultobj;
18562 fail:
18563 return NULL;
18564 }
18565
18566
18567 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18568 PyObject *resultobj = 0;
18569 wxEvent *arg1 = (wxEvent *) 0 ;
18570 bool result;
18571 void *argp1 = 0 ;
18572 int res1 = 0 ;
18573 PyObject *swig_obj[1] ;
18574
18575 if (!args) SWIG_fail;
18576 swig_obj[0] = args;
18577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18580 }
18581 arg1 = reinterpret_cast< wxEvent * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 {
18589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18590 }
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *resultobj = 0;
18599 wxEvent *arg1 = (wxEvent *) 0 ;
18600 bool result;
18601 void *argp1 = 0 ;
18602 int res1 = 0 ;
18603 PyObject *swig_obj[1] ;
18604
18605 if (!args) SWIG_fail;
18606 swig_obj[0] = args;
18607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18608 if (!SWIG_IsOK(res1)) {
18609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18610 }
18611 arg1 = reinterpret_cast< wxEvent * >(argp1);
18612 {
18613 PyThreadState* __tstate = wxPyBeginAllowThreads();
18614 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 {
18619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18620 }
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18628 PyObject *resultobj = 0;
18629 wxEvent *arg1 = (wxEvent *) 0 ;
18630 int result;
18631 void *argp1 = 0 ;
18632 int res1 = 0 ;
18633 PyObject *swig_obj[1] ;
18634
18635 if (!args) SWIG_fail;
18636 swig_obj[0] = args;
18637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvent * >(argp1);
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 result = (int)(arg1)->StopPropagation();
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 resultobj = SWIG_From_int(static_cast< int >(result));
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj = 0;
18657 wxEvent *arg1 = (wxEvent *) 0 ;
18658 int arg2 ;
18659 void *argp1 = 0 ;
18660 int res1 = 0 ;
18661 int val2 ;
18662 int ecode2 = 0 ;
18663 PyObject * obj0 = 0 ;
18664 PyObject * obj1 = 0 ;
18665 char * kwnames[] = {
18666 (char *) "self",(char *) "propagationLevel", NULL
18667 };
18668
18669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18673 }
18674 arg1 = reinterpret_cast< wxEvent * >(argp1);
18675 ecode2 = SWIG_AsVal_int(obj1, &val2);
18676 if (!SWIG_IsOK(ecode2)) {
18677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18678 }
18679 arg2 = static_cast< int >(val2);
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 (arg1)->ResumePropagation(arg2);
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_Py_Void();
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *resultobj = 0;
18695 wxEvent *arg1 = (wxEvent *) 0 ;
18696 wxEvent *result = 0 ;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 PyObject *swig_obj[1] ;
18700
18701 if (!args) SWIG_fail;
18702 swig_obj[0] = args;
18703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18706 }
18707 arg1 = reinterpret_cast< wxEvent * >(argp1);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (wxEvent *)(arg1)->Clone();
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18722 PyObject *obj;
18723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18724 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18725 return SWIG_Py_Void();
18726 }
18727
18728 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18729 PyObject *resultobj = 0;
18730 wxEvent *arg1 = 0 ;
18731 wxPropagationDisabler *result = 0 ;
18732 void *argp1 = 0 ;
18733 int res1 = 0 ;
18734 PyObject * obj0 = 0 ;
18735 char * kwnames[] = {
18736 (char *) "event", NULL
18737 };
18738
18739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18740 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18741 if (!SWIG_IsOK(res1)) {
18742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18743 }
18744 if (!argp1) {
18745 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18746 }
18747 arg1 = reinterpret_cast< wxEvent * >(argp1);
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18762 PyObject *resultobj = 0;
18763 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18764 void *argp1 = 0 ;
18765 int res1 = 0 ;
18766 PyObject *swig_obj[1] ;
18767
18768 if (!args) SWIG_fail;
18769 swig_obj[0] = args;
18770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18771 if (!SWIG_IsOK(res1)) {
18772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18773 }
18774 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 delete arg1;
18778
18779 wxPyEndAllowThreads(__tstate);
18780 if (PyErr_Occurred()) SWIG_fail;
18781 }
18782 resultobj = SWIG_Py_Void();
18783 return resultobj;
18784 fail:
18785 return NULL;
18786 }
18787
18788
18789 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18790 PyObject *obj;
18791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18792 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18793 return SWIG_Py_Void();
18794 }
18795
18796 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18797 return SWIG_Python_InitShadowInstance(args);
18798 }
18799
18800 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18801 PyObject *resultobj = 0;
18802 wxEvent *arg1 = 0 ;
18803 wxPropagateOnce *result = 0 ;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 PyObject * obj0 = 0 ;
18807 char * kwnames[] = {
18808 (char *) "event", NULL
18809 };
18810
18811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18812 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18813 if (!SWIG_IsOK(res1)) {
18814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18815 }
18816 if (!argp1) {
18817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18818 }
18819 arg1 = reinterpret_cast< wxEvent * >(argp1);
18820 {
18821 PyThreadState* __tstate = wxPyBeginAllowThreads();
18822 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18823 wxPyEndAllowThreads(__tstate);
18824 if (PyErr_Occurred()) SWIG_fail;
18825 }
18826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18827 return resultobj;
18828 fail:
18829 return NULL;
18830 }
18831
18832
18833 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18834 PyObject *resultobj = 0;
18835 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 PyObject *swig_obj[1] ;
18839
18840 if (!args) SWIG_fail;
18841 swig_obj[0] = args;
18842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18845 }
18846 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 delete arg1;
18850
18851 wxPyEndAllowThreads(__tstate);
18852 if (PyErr_Occurred()) SWIG_fail;
18853 }
18854 resultobj = SWIG_Py_Void();
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18862 PyObject *obj;
18863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18864 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18865 return SWIG_Py_Void();
18866 }
18867
18868 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18869 return SWIG_Python_InitShadowInstance(args);
18870 }
18871
18872 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj = 0;
18874 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18875 int arg2 = (int) 0 ;
18876 wxCommandEvent *result = 0 ;
18877 int val1 ;
18878 int ecode1 = 0 ;
18879 int val2 ;
18880 int ecode2 = 0 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char * kwnames[] = {
18884 (char *) "commandType",(char *) "winid", NULL
18885 };
18886
18887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18888 if (obj0) {
18889 ecode1 = SWIG_AsVal_int(obj0, &val1);
18890 if (!SWIG_IsOK(ecode1)) {
18891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18892 }
18893 arg1 = static_cast< wxEventType >(val1);
18894 }
18895 if (obj1) {
18896 ecode2 = SWIG_AsVal_int(obj1, &val2);
18897 if (!SWIG_IsOK(ecode2)) {
18898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18899 }
18900 arg2 = static_cast< int >(val2);
18901 }
18902 {
18903 PyThreadState* __tstate = wxPyBeginAllowThreads();
18904 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18905 wxPyEndAllowThreads(__tstate);
18906 if (PyErr_Occurred()) SWIG_fail;
18907 }
18908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18909 return resultobj;
18910 fail:
18911 return NULL;
18912 }
18913
18914
18915 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18916 PyObject *resultobj = 0;
18917 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18918 int result;
18919 void *argp1 = 0 ;
18920 int res1 = 0 ;
18921 PyObject *swig_obj[1] ;
18922
18923 if (!args) SWIG_fail;
18924 swig_obj[0] = args;
18925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18926 if (!SWIG_IsOK(res1)) {
18927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18928 }
18929 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18930 {
18931 PyThreadState* __tstate = wxPyBeginAllowThreads();
18932 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 resultobj = SWIG_From_int(static_cast< int >(result));
18937 return resultobj;
18938 fail:
18939 return NULL;
18940 }
18941
18942
18943 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18944 PyObject *resultobj = 0;
18945 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18946 wxString *arg2 = 0 ;
18947 void *argp1 = 0 ;
18948 int res1 = 0 ;
18949 bool temp2 = false ;
18950 PyObject * obj0 = 0 ;
18951 PyObject * obj1 = 0 ;
18952 char * kwnames[] = {
18953 (char *) "self",(char *) "s", NULL
18954 };
18955
18956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18958 if (!SWIG_IsOK(res1)) {
18959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18960 }
18961 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18962 {
18963 arg2 = wxString_in_helper(obj1);
18964 if (arg2 == NULL) SWIG_fail;
18965 temp2 = true;
18966 }
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 (arg1)->SetString((wxString const &)*arg2);
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 resultobj = SWIG_Py_Void();
18974 {
18975 if (temp2)
18976 delete arg2;
18977 }
18978 return resultobj;
18979 fail:
18980 {
18981 if (temp2)
18982 delete arg2;
18983 }
18984 return NULL;
18985 }
18986
18987
18988 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18989 PyObject *resultobj = 0;
18990 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18991 wxString result;
18992 void *argp1 = 0 ;
18993 int res1 = 0 ;
18994 PyObject *swig_obj[1] ;
18995
18996 if (!args) SWIG_fail;
18997 swig_obj[0] = args;
18998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18999 if (!SWIG_IsOK(res1)) {
19000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19001 }
19002 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19003 {
19004 PyThreadState* __tstate = wxPyBeginAllowThreads();
19005 result = ((wxCommandEvent const *)arg1)->GetString();
19006 wxPyEndAllowThreads(__tstate);
19007 if (PyErr_Occurred()) SWIG_fail;
19008 }
19009 {
19010 #if wxUSE_UNICODE
19011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19012 #else
19013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19014 #endif
19015 }
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 PyObject *resultobj = 0;
19024 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19025 bool result;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 PyObject *swig_obj[1] ;
19029
19030 if (!args) SWIG_fail;
19031 swig_obj[0] = args;
19032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19035 }
19036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 {
19044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19045 }
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19053 PyObject *resultobj = 0;
19054 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19055 bool result;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject *swig_obj[1] ;
19059
19060 if (!args) SWIG_fail;
19061 swig_obj[0] = args;
19062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19063 if (!SWIG_IsOK(res1)) {
19064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19065 }
19066 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 {
19074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19075 }
19076 return resultobj;
19077 fail:
19078 return NULL;
19079 }
19080
19081
19082 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19083 PyObject *resultobj = 0;
19084 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19085 long arg2 ;
19086 void *argp1 = 0 ;
19087 int res1 = 0 ;
19088 long val2 ;
19089 int ecode2 = 0 ;
19090 PyObject * obj0 = 0 ;
19091 PyObject * obj1 = 0 ;
19092 char * kwnames[] = {
19093 (char *) "self",(char *) "extraLong", NULL
19094 };
19095
19096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19098 if (!SWIG_IsOK(res1)) {
19099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19100 }
19101 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19102 ecode2 = SWIG_AsVal_long(obj1, &val2);
19103 if (!SWIG_IsOK(ecode2)) {
19104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19105 }
19106 arg2 = static_cast< long >(val2);
19107 {
19108 PyThreadState* __tstate = wxPyBeginAllowThreads();
19109 (arg1)->SetExtraLong(arg2);
19110 wxPyEndAllowThreads(__tstate);
19111 if (PyErr_Occurred()) SWIG_fail;
19112 }
19113 resultobj = SWIG_Py_Void();
19114 return resultobj;
19115 fail:
19116 return NULL;
19117 }
19118
19119
19120 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19121 PyObject *resultobj = 0;
19122 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19123 long result;
19124 void *argp1 = 0 ;
19125 int res1 = 0 ;
19126 PyObject *swig_obj[1] ;
19127
19128 if (!args) SWIG_fail;
19129 swig_obj[0] = args;
19130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19131 if (!SWIG_IsOK(res1)) {
19132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19133 }
19134 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19135 {
19136 PyThreadState* __tstate = wxPyBeginAllowThreads();
19137 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 resultobj = SWIG_From_long(static_cast< long >(result));
19142 return resultobj;
19143 fail:
19144 return NULL;
19145 }
19146
19147
19148 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19149 PyObject *resultobj = 0;
19150 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19151 int arg2 ;
19152 void *argp1 = 0 ;
19153 int res1 = 0 ;
19154 int val2 ;
19155 int ecode2 = 0 ;
19156 PyObject * obj0 = 0 ;
19157 PyObject * obj1 = 0 ;
19158 char * kwnames[] = {
19159 (char *) "self",(char *) "i", NULL
19160 };
19161
19162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19166 }
19167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19168 ecode2 = SWIG_AsVal_int(obj1, &val2);
19169 if (!SWIG_IsOK(ecode2)) {
19170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19171 }
19172 arg2 = static_cast< int >(val2);
19173 {
19174 PyThreadState* __tstate = wxPyBeginAllowThreads();
19175 (arg1)->SetInt(arg2);
19176 wxPyEndAllowThreads(__tstate);
19177 if (PyErr_Occurred()) SWIG_fail;
19178 }
19179 resultobj = SWIG_Py_Void();
19180 return resultobj;
19181 fail:
19182 return NULL;
19183 }
19184
19185
19186 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19187 PyObject *resultobj = 0;
19188 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19189 int result;
19190 void *argp1 = 0 ;
19191 int res1 = 0 ;
19192 PyObject *swig_obj[1] ;
19193
19194 if (!args) SWIG_fail;
19195 swig_obj[0] = args;
19196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19197 if (!SWIG_IsOK(res1)) {
19198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19199 }
19200 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 resultobj = SWIG_From_int(static_cast< int >(result));
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19215 PyObject *resultobj = 0;
19216 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19217 PyObject *result = 0 ;
19218 void *argp1 = 0 ;
19219 int res1 = 0 ;
19220 PyObject *swig_obj[1] ;
19221
19222 if (!args) SWIG_fail;
19223 swig_obj[0] = args;
19224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19227 }
19228 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 resultobj = result;
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19243 PyObject *resultobj = 0;
19244 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19245 PyObject *arg2 = (PyObject *) 0 ;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 PyObject * obj0 = 0 ;
19249 PyObject * obj1 = 0 ;
19250 char * kwnames[] = {
19251 (char *) "self",(char *) "clientData", NULL
19252 };
19253
19254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19256 if (!SWIG_IsOK(res1)) {
19257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19258 }
19259 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19260 arg2 = obj1;
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 wxCommandEvent_SetClientData(arg1,arg2);
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 resultobj = SWIG_Py_Void();
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19275 PyObject *resultobj = 0;
19276 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19277 wxEvent *result = 0 ;
19278 void *argp1 = 0 ;
19279 int res1 = 0 ;
19280 PyObject *swig_obj[1] ;
19281
19282 if (!args) SWIG_fail;
19283 swig_obj[0] = args;
19284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19285 if (!SWIG_IsOK(res1)) {
19286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19287 }
19288 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19289 {
19290 PyThreadState* __tstate = wxPyBeginAllowThreads();
19291 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19303 PyObject *obj;
19304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19305 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19306 return SWIG_Py_Void();
19307 }
19308
19309 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19310 return SWIG_Python_InitShadowInstance(args);
19311 }
19312
19313 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj = 0;
19315 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19316 int arg2 = (int) 0 ;
19317 wxNotifyEvent *result = 0 ;
19318 int val1 ;
19319 int ecode1 = 0 ;
19320 int val2 ;
19321 int ecode2 = 0 ;
19322 PyObject * obj0 = 0 ;
19323 PyObject * obj1 = 0 ;
19324 char * kwnames[] = {
19325 (char *) "commandType",(char *) "winid", NULL
19326 };
19327
19328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19329 if (obj0) {
19330 ecode1 = SWIG_AsVal_int(obj0, &val1);
19331 if (!SWIG_IsOK(ecode1)) {
19332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19333 }
19334 arg1 = static_cast< wxEventType >(val1);
19335 }
19336 if (obj1) {
19337 ecode2 = SWIG_AsVal_int(obj1, &val2);
19338 if (!SWIG_IsOK(ecode2)) {
19339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19340 }
19341 arg2 = static_cast< int >(val2);
19342 }
19343 {
19344 PyThreadState* __tstate = wxPyBeginAllowThreads();
19345 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19346 wxPyEndAllowThreads(__tstate);
19347 if (PyErr_Occurred()) SWIG_fail;
19348 }
19349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19350 return resultobj;
19351 fail:
19352 return NULL;
19353 }
19354
19355
19356 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19357 PyObject *resultobj = 0;
19358 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19359 void *argp1 = 0 ;
19360 int res1 = 0 ;
19361 PyObject *swig_obj[1] ;
19362
19363 if (!args) SWIG_fail;
19364 swig_obj[0] = args;
19365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19366 if (!SWIG_IsOK(res1)) {
19367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19368 }
19369 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19370 {
19371 PyThreadState* __tstate = wxPyBeginAllowThreads();
19372 (arg1)->Veto();
19373 wxPyEndAllowThreads(__tstate);
19374 if (PyErr_Occurred()) SWIG_fail;
19375 }
19376 resultobj = SWIG_Py_Void();
19377 return resultobj;
19378 fail:
19379 return NULL;
19380 }
19381
19382
19383 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19384 PyObject *resultobj = 0;
19385 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19386 void *argp1 = 0 ;
19387 int res1 = 0 ;
19388 PyObject *swig_obj[1] ;
19389
19390 if (!args) SWIG_fail;
19391 swig_obj[0] = args;
19392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19393 if (!SWIG_IsOK(res1)) {
19394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19395 }
19396 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 (arg1)->Allow();
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_Py_Void();
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 PyObject *resultobj = 0;
19412 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19413 bool result;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 PyObject *swig_obj[1] ;
19417
19418 if (!args) SWIG_fail;
19419 swig_obj[0] = args;
19420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19423 }
19424 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (bool)(arg1)->IsAllowed();
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 {
19432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19433 }
19434 return resultobj;
19435 fail:
19436 return NULL;
19437 }
19438
19439
19440 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19441 PyObject *obj;
19442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19443 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19444 return SWIG_Py_Void();
19445 }
19446
19447 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19448 return SWIG_Python_InitShadowInstance(args);
19449 }
19450
19451 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj = 0;
19453 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19454 int arg2 = (int) 0 ;
19455 int arg3 = (int) 0 ;
19456 int arg4 = (int) 0 ;
19457 wxScrollEvent *result = 0 ;
19458 int val1 ;
19459 int ecode1 = 0 ;
19460 int val2 ;
19461 int ecode2 = 0 ;
19462 int val3 ;
19463 int ecode3 = 0 ;
19464 int val4 ;
19465 int ecode4 = 0 ;
19466 PyObject * obj0 = 0 ;
19467 PyObject * obj1 = 0 ;
19468 PyObject * obj2 = 0 ;
19469 PyObject * obj3 = 0 ;
19470 char * kwnames[] = {
19471 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19472 };
19473
19474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19475 if (obj0) {
19476 ecode1 = SWIG_AsVal_int(obj0, &val1);
19477 if (!SWIG_IsOK(ecode1)) {
19478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19479 }
19480 arg1 = static_cast< wxEventType >(val1);
19481 }
19482 if (obj1) {
19483 ecode2 = SWIG_AsVal_int(obj1, &val2);
19484 if (!SWIG_IsOK(ecode2)) {
19485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19486 }
19487 arg2 = static_cast< int >(val2);
19488 }
19489 if (obj2) {
19490 ecode3 = SWIG_AsVal_int(obj2, &val3);
19491 if (!SWIG_IsOK(ecode3)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19493 }
19494 arg3 = static_cast< int >(val3);
19495 }
19496 if (obj3) {
19497 ecode4 = SWIG_AsVal_int(obj3, &val4);
19498 if (!SWIG_IsOK(ecode4)) {
19499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19500 }
19501 arg4 = static_cast< int >(val4);
19502 }
19503 {
19504 PyThreadState* __tstate = wxPyBeginAllowThreads();
19505 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19506 wxPyEndAllowThreads(__tstate);
19507 if (PyErr_Occurred()) SWIG_fail;
19508 }
19509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19510 return resultobj;
19511 fail:
19512 return NULL;
19513 }
19514
19515
19516 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19517 PyObject *resultobj = 0;
19518 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19519 int result;
19520 void *argp1 = 0 ;
19521 int res1 = 0 ;
19522 PyObject *swig_obj[1] ;
19523
19524 if (!args) SWIG_fail;
19525 swig_obj[0] = args;
19526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19527 if (!SWIG_IsOK(res1)) {
19528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19529 }
19530 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19531 {
19532 PyThreadState* __tstate = wxPyBeginAllowThreads();
19533 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 resultobj = SWIG_From_int(static_cast< int >(result));
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19545 PyObject *resultobj = 0;
19546 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19547 int result;
19548 void *argp1 = 0 ;
19549 int res1 = 0 ;
19550 PyObject *swig_obj[1] ;
19551
19552 if (!args) SWIG_fail;
19553 swig_obj[0] = args;
19554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19555 if (!SWIG_IsOK(res1)) {
19556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19557 }
19558 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19562 wxPyEndAllowThreads(__tstate);
19563 if (PyErr_Occurred()) SWIG_fail;
19564 }
19565 resultobj = SWIG_From_int(static_cast< int >(result));
19566 return resultobj;
19567 fail:
19568 return NULL;
19569 }
19570
19571
19572 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19573 PyObject *resultobj = 0;
19574 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19575 int arg2 ;
19576 void *argp1 = 0 ;
19577 int res1 = 0 ;
19578 int val2 ;
19579 int ecode2 = 0 ;
19580 PyObject * obj0 = 0 ;
19581 PyObject * obj1 = 0 ;
19582 char * kwnames[] = {
19583 (char *) "self",(char *) "orient", NULL
19584 };
19585
19586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19588 if (!SWIG_IsOK(res1)) {
19589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19590 }
19591 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19592 ecode2 = SWIG_AsVal_int(obj1, &val2);
19593 if (!SWIG_IsOK(ecode2)) {
19594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19595 }
19596 arg2 = static_cast< int >(val2);
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 (arg1)->SetOrientation(arg2);
19600 wxPyEndAllowThreads(__tstate);
19601 if (PyErr_Occurred()) SWIG_fail;
19602 }
19603 resultobj = SWIG_Py_Void();
19604 return resultobj;
19605 fail:
19606 return NULL;
19607 }
19608
19609
19610 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19611 PyObject *resultobj = 0;
19612 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19613 int arg2 ;
19614 void *argp1 = 0 ;
19615 int res1 = 0 ;
19616 int val2 ;
19617 int ecode2 = 0 ;
19618 PyObject * obj0 = 0 ;
19619 PyObject * obj1 = 0 ;
19620 char * kwnames[] = {
19621 (char *) "self",(char *) "pos", NULL
19622 };
19623
19624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19628 }
19629 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19630 ecode2 = SWIG_AsVal_int(obj1, &val2);
19631 if (!SWIG_IsOK(ecode2)) {
19632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19633 }
19634 arg2 = static_cast< int >(val2);
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 (arg1)->SetPosition(arg2);
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 resultobj = SWIG_Py_Void();
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19649 PyObject *obj;
19650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19651 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19652 return SWIG_Py_Void();
19653 }
19654
19655 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19656 return SWIG_Python_InitShadowInstance(args);
19657 }
19658
19659 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19660 PyObject *resultobj = 0;
19661 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19662 int arg2 = (int) 0 ;
19663 int arg3 = (int) 0 ;
19664 wxScrollWinEvent *result = 0 ;
19665 int val1 ;
19666 int ecode1 = 0 ;
19667 int val2 ;
19668 int ecode2 = 0 ;
19669 int val3 ;
19670 int ecode3 = 0 ;
19671 PyObject * obj0 = 0 ;
19672 PyObject * obj1 = 0 ;
19673 PyObject * obj2 = 0 ;
19674 char * kwnames[] = {
19675 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19676 };
19677
19678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19679 if (obj0) {
19680 ecode1 = SWIG_AsVal_int(obj0, &val1);
19681 if (!SWIG_IsOK(ecode1)) {
19682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19683 }
19684 arg1 = static_cast< wxEventType >(val1);
19685 }
19686 if (obj1) {
19687 ecode2 = SWIG_AsVal_int(obj1, &val2);
19688 if (!SWIG_IsOK(ecode2)) {
19689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19690 }
19691 arg2 = static_cast< int >(val2);
19692 }
19693 if (obj2) {
19694 ecode3 = SWIG_AsVal_int(obj2, &val3);
19695 if (!SWIG_IsOK(ecode3)) {
19696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19697 }
19698 arg3 = static_cast< int >(val3);
19699 }
19700 {
19701 PyThreadState* __tstate = wxPyBeginAllowThreads();
19702 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19714 PyObject *resultobj = 0;
19715 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19716 int result;
19717 void *argp1 = 0 ;
19718 int res1 = 0 ;
19719 PyObject *swig_obj[1] ;
19720
19721 if (!args) SWIG_fail;
19722 swig_obj[0] = args;
19723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19724 if (!SWIG_IsOK(res1)) {
19725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19726 }
19727 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_From_int(static_cast< int >(result));
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19742 PyObject *resultobj = 0;
19743 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19744 int result;
19745 void *argp1 = 0 ;
19746 int res1 = 0 ;
19747 PyObject *swig_obj[1] ;
19748
19749 if (!args) SWIG_fail;
19750 swig_obj[0] = args;
19751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19754 }
19755 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19759 wxPyEndAllowThreads(__tstate);
19760 if (PyErr_Occurred()) SWIG_fail;
19761 }
19762 resultobj = SWIG_From_int(static_cast< int >(result));
19763 return resultobj;
19764 fail:
19765 return NULL;
19766 }
19767
19768
19769 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj = 0;
19771 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19772 int arg2 ;
19773 void *argp1 = 0 ;
19774 int res1 = 0 ;
19775 int val2 ;
19776 int ecode2 = 0 ;
19777 PyObject * obj0 = 0 ;
19778 PyObject * obj1 = 0 ;
19779 char * kwnames[] = {
19780 (char *) "self",(char *) "orient", NULL
19781 };
19782
19783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19785 if (!SWIG_IsOK(res1)) {
19786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19787 }
19788 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19789 ecode2 = SWIG_AsVal_int(obj1, &val2);
19790 if (!SWIG_IsOK(ecode2)) {
19791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19792 }
19793 arg2 = static_cast< int >(val2);
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 (arg1)->SetOrientation(arg2);
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 resultobj = SWIG_Py_Void();
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj = 0;
19809 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19810 int arg2 ;
19811 void *argp1 = 0 ;
19812 int res1 = 0 ;
19813 int val2 ;
19814 int ecode2 = 0 ;
19815 PyObject * obj0 = 0 ;
19816 PyObject * obj1 = 0 ;
19817 char * kwnames[] = {
19818 (char *) "self",(char *) "pos", NULL
19819 };
19820
19821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19825 }
19826 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19827 ecode2 = SWIG_AsVal_int(obj1, &val2);
19828 if (!SWIG_IsOK(ecode2)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19830 }
19831 arg2 = static_cast< int >(val2);
19832 {
19833 PyThreadState* __tstate = wxPyBeginAllowThreads();
19834 (arg1)->SetPosition(arg2);
19835 wxPyEndAllowThreads(__tstate);
19836 if (PyErr_Occurred()) SWIG_fail;
19837 }
19838 resultobj = SWIG_Py_Void();
19839 return resultobj;
19840 fail:
19841 return NULL;
19842 }
19843
19844
19845 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19846 PyObject *obj;
19847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19848 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19849 return SWIG_Py_Void();
19850 }
19851
19852 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19853 return SWIG_Python_InitShadowInstance(args);
19854 }
19855
19856 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19857 PyObject *resultobj = 0;
19858 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19859 wxMouseEvent *result = 0 ;
19860 int val1 ;
19861 int ecode1 = 0 ;
19862 PyObject * obj0 = 0 ;
19863 char * kwnames[] = {
19864 (char *) "mouseType", NULL
19865 };
19866
19867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19868 if (obj0) {
19869 ecode1 = SWIG_AsVal_int(obj0, &val1);
19870 if (!SWIG_IsOK(ecode1)) {
19871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19872 }
19873 arg1 = static_cast< wxEventType >(val1);
19874 }
19875 {
19876 PyThreadState* __tstate = wxPyBeginAllowThreads();
19877 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19878 wxPyEndAllowThreads(__tstate);
19879 if (PyErr_Occurred()) SWIG_fail;
19880 }
19881 {
19882 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19883 }
19884 return resultobj;
19885 fail:
19886 return NULL;
19887 }
19888
19889
19890 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19891 PyObject *resultobj = 0;
19892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19893 bool result;
19894 void *argp1 = 0 ;
19895 int res1 = 0 ;
19896 PyObject *swig_obj[1] ;
19897
19898 if (!args) SWIG_fail;
19899 swig_obj[0] = args;
19900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19901 if (!SWIG_IsOK(res1)) {
19902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19903 }
19904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19905 {
19906 PyThreadState* __tstate = wxPyBeginAllowThreads();
19907 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19908 wxPyEndAllowThreads(__tstate);
19909 if (PyErr_Occurred()) SWIG_fail;
19910 }
19911 {
19912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19913 }
19914 return resultobj;
19915 fail:
19916 return NULL;
19917 }
19918
19919
19920 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19921 PyObject *resultobj = 0;
19922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19923 int arg2 = (int) wxMOUSE_BTN_ANY ;
19924 bool result;
19925 void *argp1 = 0 ;
19926 int res1 = 0 ;
19927 int val2 ;
19928 int ecode2 = 0 ;
19929 PyObject * obj0 = 0 ;
19930 PyObject * obj1 = 0 ;
19931 char * kwnames[] = {
19932 (char *) "self",(char *) "but", NULL
19933 };
19934
19935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19937 if (!SWIG_IsOK(res1)) {
19938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19939 }
19940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19941 if (obj1) {
19942 ecode2 = SWIG_AsVal_int(obj1, &val2);
19943 if (!SWIG_IsOK(ecode2)) {
19944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19945 }
19946 arg2 = static_cast< int >(val2);
19947 }
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 {
19955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19956 }
19957 return resultobj;
19958 fail:
19959 return NULL;
19960 }
19961
19962
19963 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19964 PyObject *resultobj = 0;
19965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19966 int arg2 = (int) wxMOUSE_BTN_ANY ;
19967 bool result;
19968 void *argp1 = 0 ;
19969 int res1 = 0 ;
19970 int val2 ;
19971 int ecode2 = 0 ;
19972 PyObject * obj0 = 0 ;
19973 PyObject * obj1 = 0 ;
19974 char * kwnames[] = {
19975 (char *) "self",(char *) "but", NULL
19976 };
19977
19978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19980 if (!SWIG_IsOK(res1)) {
19981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19982 }
19983 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19984 if (obj1) {
19985 ecode2 = SWIG_AsVal_int(obj1, &val2);
19986 if (!SWIG_IsOK(ecode2)) {
19987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19988 }
19989 arg2 = static_cast< int >(val2);
19990 }
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19994 wxPyEndAllowThreads(__tstate);
19995 if (PyErr_Occurred()) SWIG_fail;
19996 }
19997 {
19998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19999 }
20000 return resultobj;
20001 fail:
20002 return NULL;
20003 }
20004
20005
20006 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20007 PyObject *resultobj = 0;
20008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20009 int arg2 = (int) wxMOUSE_BTN_ANY ;
20010 bool result;
20011 void *argp1 = 0 ;
20012 int res1 = 0 ;
20013 int val2 ;
20014 int ecode2 = 0 ;
20015 PyObject * obj0 = 0 ;
20016 PyObject * obj1 = 0 ;
20017 char * kwnames[] = {
20018 (char *) "self",(char *) "but", NULL
20019 };
20020
20021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20025 }
20026 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20027 if (obj1) {
20028 ecode2 = SWIG_AsVal_int(obj1, &val2);
20029 if (!SWIG_IsOK(ecode2)) {
20030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20031 }
20032 arg2 = static_cast< int >(val2);
20033 }
20034 {
20035 PyThreadState* __tstate = wxPyBeginAllowThreads();
20036 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20037 wxPyEndAllowThreads(__tstate);
20038 if (PyErr_Occurred()) SWIG_fail;
20039 }
20040 {
20041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20042 }
20043 return resultobj;
20044 fail:
20045 return NULL;
20046 }
20047
20048
20049 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20050 PyObject *resultobj = 0;
20051 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20052 int arg2 ;
20053 bool result;
20054 void *argp1 = 0 ;
20055 int res1 = 0 ;
20056 int val2 ;
20057 int ecode2 = 0 ;
20058 PyObject * obj0 = 0 ;
20059 PyObject * obj1 = 0 ;
20060 char * kwnames[] = {
20061 (char *) "self",(char *) "button", NULL
20062 };
20063
20064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20066 if (!SWIG_IsOK(res1)) {
20067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20068 }
20069 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20070 ecode2 = SWIG_AsVal_int(obj1, &val2);
20071 if (!SWIG_IsOK(ecode2)) {
20072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20073 }
20074 arg2 = static_cast< int >(val2);
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20078 wxPyEndAllowThreads(__tstate);
20079 if (PyErr_Occurred()) SWIG_fail;
20080 }
20081 {
20082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20083 }
20084 return resultobj;
20085 fail:
20086 return NULL;
20087 }
20088
20089
20090 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20091 PyObject *resultobj = 0;
20092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20093 int arg2 ;
20094 bool result;
20095 void *argp1 = 0 ;
20096 int res1 = 0 ;
20097 int val2 ;
20098 int ecode2 = 0 ;
20099 PyObject * obj0 = 0 ;
20100 PyObject * obj1 = 0 ;
20101 char * kwnames[] = {
20102 (char *) "self",(char *) "but", NULL
20103 };
20104
20105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20107 if (!SWIG_IsOK(res1)) {
20108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20109 }
20110 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20111 ecode2 = SWIG_AsVal_int(obj1, &val2);
20112 if (!SWIG_IsOK(ecode2)) {
20113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20114 }
20115 arg2 = static_cast< int >(val2);
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 {
20123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20124 }
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20132 PyObject *resultobj = 0;
20133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20134 int result;
20135 void *argp1 = 0 ;
20136 int res1 = 0 ;
20137 PyObject *swig_obj[1] ;
20138
20139 if (!args) SWIG_fail;
20140 swig_obj[0] = args;
20141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20142 if (!SWIG_IsOK(res1)) {
20143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20144 }
20145 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 resultobj = SWIG_From_int(static_cast< int >(result));
20153 return resultobj;
20154 fail:
20155 return NULL;
20156 }
20157
20158
20159 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20160 PyObject *resultobj = 0;
20161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20162 bool result;
20163 void *argp1 = 0 ;
20164 int res1 = 0 ;
20165 PyObject *swig_obj[1] ;
20166
20167 if (!args) SWIG_fail;
20168 swig_obj[0] = args;
20169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20170 if (!SWIG_IsOK(res1)) {
20171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20172 }
20173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20177 wxPyEndAllowThreads(__tstate);
20178 if (PyErr_Occurred()) SWIG_fail;
20179 }
20180 {
20181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20182 }
20183 return resultobj;
20184 fail:
20185 return NULL;
20186 }
20187
20188
20189 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20190 PyObject *resultobj = 0;
20191 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20192 bool result;
20193 void *argp1 = 0 ;
20194 int res1 = 0 ;
20195 PyObject *swig_obj[1] ;
20196
20197 if (!args) SWIG_fail;
20198 swig_obj[0] = args;
20199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20200 if (!SWIG_IsOK(res1)) {
20201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20202 }
20203 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20204 {
20205 PyThreadState* __tstate = wxPyBeginAllowThreads();
20206 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 {
20211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20212 }
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20220 PyObject *resultobj = 0;
20221 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20222 bool result;
20223 void *argp1 = 0 ;
20224 int res1 = 0 ;
20225 PyObject *swig_obj[1] ;
20226
20227 if (!args) SWIG_fail;
20228 swig_obj[0] = args;
20229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20230 if (!SWIG_IsOK(res1)) {
20231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20232 }
20233 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 {
20241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20242 }
20243 return resultobj;
20244 fail:
20245 return NULL;
20246 }
20247
20248
20249 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20250 PyObject *resultobj = 0;
20251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20252 bool result;
20253 void *argp1 = 0 ;
20254 int res1 = 0 ;
20255 PyObject *swig_obj[1] ;
20256
20257 if (!args) SWIG_fail;
20258 swig_obj[0] = args;
20259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20260 if (!SWIG_IsOK(res1)) {
20261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20262 }
20263 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20264 {
20265 PyThreadState* __tstate = wxPyBeginAllowThreads();
20266 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20267 wxPyEndAllowThreads(__tstate);
20268 if (PyErr_Occurred()) SWIG_fail;
20269 }
20270 {
20271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20272 }
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20280 PyObject *resultobj = 0;
20281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20282 bool result;
20283 void *argp1 = 0 ;
20284 int res1 = 0 ;
20285 PyObject *swig_obj[1] ;
20286
20287 if (!args) SWIG_fail;
20288 swig_obj[0] = args;
20289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20290 if (!SWIG_IsOK(res1)) {
20291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20292 }
20293 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20294 {
20295 PyThreadState* __tstate = wxPyBeginAllowThreads();
20296 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20297 wxPyEndAllowThreads(__tstate);
20298 if (PyErr_Occurred()) SWIG_fail;
20299 }
20300 {
20301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20302 }
20303 return resultobj;
20304 fail:
20305 return NULL;
20306 }
20307
20308
20309 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20310 PyObject *resultobj = 0;
20311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20312 bool result;
20313 void *argp1 = 0 ;
20314 int res1 = 0 ;
20315 PyObject *swig_obj[1] ;
20316
20317 if (!args) SWIG_fail;
20318 swig_obj[0] = args;
20319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20320 if (!SWIG_IsOK(res1)) {
20321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20322 }
20323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20327 wxPyEndAllowThreads(__tstate);
20328 if (PyErr_Occurred()) SWIG_fail;
20329 }
20330 {
20331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20332 }
20333 return resultobj;
20334 fail:
20335 return NULL;
20336 }
20337
20338
20339 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20340 PyObject *resultobj = 0;
20341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20342 bool result;
20343 void *argp1 = 0 ;
20344 int res1 = 0 ;
20345 PyObject *swig_obj[1] ;
20346
20347 if (!args) SWIG_fail;
20348 swig_obj[0] = args;
20349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20350 if (!SWIG_IsOK(res1)) {
20351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20352 }
20353 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20354 {
20355 PyThreadState* __tstate = wxPyBeginAllowThreads();
20356 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20357 wxPyEndAllowThreads(__tstate);
20358 if (PyErr_Occurred()) SWIG_fail;
20359 }
20360 {
20361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20362 }
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20370 PyObject *resultobj = 0;
20371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20372 bool result;
20373 void *argp1 = 0 ;
20374 int res1 = 0 ;
20375 PyObject *swig_obj[1] ;
20376
20377 if (!args) SWIG_fail;
20378 swig_obj[0] = args;
20379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20380 if (!SWIG_IsOK(res1)) {
20381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20382 }
20383 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20384 {
20385 PyThreadState* __tstate = wxPyBeginAllowThreads();
20386 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 {
20391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20392 }
20393 return resultobj;
20394 fail:
20395 return NULL;
20396 }
20397
20398
20399 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 PyObject *resultobj = 0;
20401 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20402 bool result;
20403 void *argp1 = 0 ;
20404 int res1 = 0 ;
20405 PyObject *swig_obj[1] ;
20406
20407 if (!args) SWIG_fail;
20408 swig_obj[0] = args;
20409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20410 if (!SWIG_IsOK(res1)) {
20411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20412 }
20413 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 {
20421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20422 }
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20430 PyObject *resultobj = 0;
20431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20432 bool result;
20433 void *argp1 = 0 ;
20434 int res1 = 0 ;
20435 PyObject *swig_obj[1] ;
20436
20437 if (!args) SWIG_fail;
20438 swig_obj[0] = args;
20439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20440 if (!SWIG_IsOK(res1)) {
20441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20442 }
20443 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20444 {
20445 PyThreadState* __tstate = wxPyBeginAllowThreads();
20446 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 {
20451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20452 }
20453 return resultobj;
20454 fail:
20455 return NULL;
20456 }
20457
20458
20459 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20460 PyObject *resultobj = 0;
20461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20462 bool result;
20463 void *argp1 = 0 ;
20464 int res1 = 0 ;
20465 PyObject *swig_obj[1] ;
20466
20467 if (!args) SWIG_fail;
20468 swig_obj[0] = args;
20469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20470 if (!SWIG_IsOK(res1)) {
20471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20472 }
20473 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20474 {
20475 PyThreadState* __tstate = wxPyBeginAllowThreads();
20476 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20477 wxPyEndAllowThreads(__tstate);
20478 if (PyErr_Occurred()) SWIG_fail;
20479 }
20480 {
20481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20482 }
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20490 PyObject *resultobj = 0;
20491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20492 bool result;
20493 void *argp1 = 0 ;
20494 int res1 = 0 ;
20495 PyObject *swig_obj[1] ;
20496
20497 if (!args) SWIG_fail;
20498 swig_obj[0] = args;
20499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20500 if (!SWIG_IsOK(res1)) {
20501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20502 }
20503 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20504 {
20505 PyThreadState* __tstate = wxPyBeginAllowThreads();
20506 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 {
20511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20512 }
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20520 PyObject *resultobj = 0;
20521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20522 bool result;
20523 void *argp1 = 0 ;
20524 int res1 = 0 ;
20525 PyObject *swig_obj[1] ;
20526
20527 if (!args) SWIG_fail;
20528 swig_obj[0] = args;
20529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20530 if (!SWIG_IsOK(res1)) {
20531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20532 }
20533 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 {
20541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20542 }
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20550 PyObject *resultobj = 0;
20551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20552 bool result;
20553 void *argp1 = 0 ;
20554 int res1 = 0 ;
20555 PyObject *swig_obj[1] ;
20556
20557 if (!args) SWIG_fail;
20558 swig_obj[0] = args;
20559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20560 if (!SWIG_IsOK(res1)) {
20561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20562 }
20563 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20564 {
20565 PyThreadState* __tstate = wxPyBeginAllowThreads();
20566 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20567 wxPyEndAllowThreads(__tstate);
20568 if (PyErr_Occurred()) SWIG_fail;
20569 }
20570 {
20571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20572 }
20573 return resultobj;
20574 fail:
20575 return NULL;
20576 }
20577
20578
20579 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20580 PyObject *resultobj = 0;
20581 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20582 bool result;
20583 void *argp1 = 0 ;
20584 int res1 = 0 ;
20585 PyObject *swig_obj[1] ;
20586
20587 if (!args) SWIG_fail;
20588 swig_obj[0] = args;
20589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20590 if (!SWIG_IsOK(res1)) {
20591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20592 }
20593 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20594 {
20595 PyThreadState* __tstate = wxPyBeginAllowThreads();
20596 result = (bool)(arg1)->LeftIsDown();
20597 wxPyEndAllowThreads(__tstate);
20598 if (PyErr_Occurred()) SWIG_fail;
20599 }
20600 {
20601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20602 }
20603 return resultobj;
20604 fail:
20605 return NULL;
20606 }
20607
20608
20609 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20610 PyObject *resultobj = 0;
20611 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20612 bool result;
20613 void *argp1 = 0 ;
20614 int res1 = 0 ;
20615 PyObject *swig_obj[1] ;
20616
20617 if (!args) SWIG_fail;
20618 swig_obj[0] = args;
20619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20620 if (!SWIG_IsOK(res1)) {
20621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20622 }
20623 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20624 {
20625 PyThreadState* __tstate = wxPyBeginAllowThreads();
20626 result = (bool)(arg1)->MiddleIsDown();
20627 wxPyEndAllowThreads(__tstate);
20628 if (PyErr_Occurred()) SWIG_fail;
20629 }
20630 {
20631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20632 }
20633 return resultobj;
20634 fail:
20635 return NULL;
20636 }
20637
20638
20639 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20640 PyObject *resultobj = 0;
20641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20642 bool result;
20643 void *argp1 = 0 ;
20644 int res1 = 0 ;
20645 PyObject *swig_obj[1] ;
20646
20647 if (!args) SWIG_fail;
20648 swig_obj[0] = args;
20649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20650 if (!SWIG_IsOK(res1)) {
20651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20652 }
20653 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20654 {
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = (bool)(arg1)->RightIsDown();
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 {
20661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20662 }
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20670 PyObject *resultobj = 0;
20671 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20672 bool result;
20673 void *argp1 = 0 ;
20674 int res1 = 0 ;
20675 PyObject *swig_obj[1] ;
20676
20677 if (!args) SWIG_fail;
20678 swig_obj[0] = args;
20679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20680 if (!SWIG_IsOK(res1)) {
20681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20682 }
20683 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20687 wxPyEndAllowThreads(__tstate);
20688 if (PyErr_Occurred()) SWIG_fail;
20689 }
20690 {
20691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20692 }
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20700 PyObject *resultobj = 0;
20701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20702 bool result;
20703 void *argp1 = 0 ;
20704 int res1 = 0 ;
20705 PyObject *swig_obj[1] ;
20706
20707 if (!args) SWIG_fail;
20708 swig_obj[0] = args;
20709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20710 if (!SWIG_IsOK(res1)) {
20711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20712 }
20713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20714 {
20715 PyThreadState* __tstate = wxPyBeginAllowThreads();
20716 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 {
20721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20722 }
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20730 PyObject *resultobj = 0;
20731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20732 bool result;
20733 void *argp1 = 0 ;
20734 int res1 = 0 ;
20735 PyObject *swig_obj[1] ;
20736
20737 if (!args) SWIG_fail;
20738 swig_obj[0] = args;
20739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20740 if (!SWIG_IsOK(res1)) {
20741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20742 }
20743 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 {
20751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20752 }
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20760 PyObject *resultobj = 0;
20761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20762 bool result;
20763 void *argp1 = 0 ;
20764 int res1 = 0 ;
20765 PyObject *swig_obj[1] ;
20766
20767 if (!args) SWIG_fail;
20768 swig_obj[0] = args;
20769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20770 if (!SWIG_IsOK(res1)) {
20771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20772 }
20773 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20774 {
20775 PyThreadState* __tstate = wxPyBeginAllowThreads();
20776 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20777 wxPyEndAllowThreads(__tstate);
20778 if (PyErr_Occurred()) SWIG_fail;
20779 }
20780 {
20781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20782 }
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20790 PyObject *resultobj = 0;
20791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20792 wxPoint result;
20793 void *argp1 = 0 ;
20794 int res1 = 0 ;
20795 PyObject *swig_obj[1] ;
20796
20797 if (!args) SWIG_fail;
20798 swig_obj[0] = args;
20799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20800 if (!SWIG_IsOK(res1)) {
20801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20802 }
20803 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (arg1)->GetPosition();
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20811 return resultobj;
20812 fail:
20813 return NULL;
20814 }
20815
20816
20817 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20818 PyObject *resultobj = 0;
20819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20820 long *arg2 = (long *) 0 ;
20821 long *arg3 = (long *) 0 ;
20822 void *argp1 = 0 ;
20823 int res1 = 0 ;
20824 long temp2 ;
20825 int res2 = SWIG_TMPOBJ ;
20826 long temp3 ;
20827 int res3 = SWIG_TMPOBJ ;
20828 PyObject *swig_obj[1] ;
20829
20830 arg2 = &temp2;
20831 arg3 = &temp3;
20832 if (!args) SWIG_fail;
20833 swig_obj[0] = args;
20834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20837 }
20838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20839 {
20840 PyThreadState* __tstate = wxPyBeginAllowThreads();
20841 (arg1)->GetPosition(arg2,arg3);
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 resultobj = SWIG_Py_Void();
20846 if (SWIG_IsTmpObj(res2)) {
20847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20848 } else {
20849 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20851 }
20852 if (SWIG_IsTmpObj(res3)) {
20853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20854 } else {
20855 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20857 }
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20865 PyObject *resultobj = 0;
20866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20867 wxDC *arg2 = 0 ;
20868 wxPoint result;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 void *argp2 = 0 ;
20872 int res2 = 0 ;
20873 PyObject * obj0 = 0 ;
20874 PyObject * obj1 = 0 ;
20875 char * kwnames[] = {
20876 (char *) "self",(char *) "dc", NULL
20877 };
20878
20879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20881 if (!SWIG_IsOK(res1)) {
20882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20883 }
20884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20886 if (!SWIG_IsOK(res2)) {
20887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20888 }
20889 if (!argp2) {
20890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20891 }
20892 arg2 = reinterpret_cast< wxDC * >(argp2);
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20900 return resultobj;
20901 fail:
20902 return NULL;
20903 }
20904
20905
20906 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20907 PyObject *resultobj = 0;
20908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20909 int 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_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20919 }
20920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 result = (int)((wxMouseEvent const *)arg1)->GetX();
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 resultobj = SWIG_From_int(static_cast< int >(result));
20928 return resultobj;
20929 fail:
20930 return NULL;
20931 }
20932
20933
20934 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20935 PyObject *resultobj = 0;
20936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20937 int result;
20938 void *argp1 = 0 ;
20939 int res1 = 0 ;
20940 PyObject *swig_obj[1] ;
20941
20942 if (!args) SWIG_fail;
20943 swig_obj[0] = args;
20944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20945 if (!SWIG_IsOK(res1)) {
20946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20947 }
20948 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 result = (int)((wxMouseEvent const *)arg1)->GetY();
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 resultobj = SWIG_From_int(static_cast< int >(result));
20956 return resultobj;
20957 fail:
20958 return NULL;
20959 }
20960
20961
20962 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20963 PyObject *resultobj = 0;
20964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20965 int result;
20966 void *argp1 = 0 ;
20967 int res1 = 0 ;
20968 PyObject *swig_obj[1] ;
20969
20970 if (!args) SWIG_fail;
20971 swig_obj[0] = args;
20972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20973 if (!SWIG_IsOK(res1)) {
20974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20975 }
20976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20980 wxPyEndAllowThreads(__tstate);
20981 if (PyErr_Occurred()) SWIG_fail;
20982 }
20983 resultobj = SWIG_From_int(static_cast< int >(result));
20984 return resultobj;
20985 fail:
20986 return NULL;
20987 }
20988
20989
20990 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20991 PyObject *resultobj = 0;
20992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20993 int result;
20994 void *argp1 = 0 ;
20995 int res1 = 0 ;
20996 PyObject *swig_obj[1] ;
20997
20998 if (!args) SWIG_fail;
20999 swig_obj[0] = args;
21000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21001 if (!SWIG_IsOK(res1)) {
21002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21003 }
21004 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21005 {
21006 PyThreadState* __tstate = wxPyBeginAllowThreads();
21007 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21008 wxPyEndAllowThreads(__tstate);
21009 if (PyErr_Occurred()) SWIG_fail;
21010 }
21011 resultobj = SWIG_From_int(static_cast< int >(result));
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21019 PyObject *resultobj = 0;
21020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21021 int result;
21022 void *argp1 = 0 ;
21023 int res1 = 0 ;
21024 PyObject *swig_obj[1] ;
21025
21026 if (!args) SWIG_fail;
21027 swig_obj[0] = args;
21028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21029 if (!SWIG_IsOK(res1)) {
21030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21031 }
21032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 resultobj = SWIG_From_int(static_cast< int >(result));
21040 return resultobj;
21041 fail:
21042 return NULL;
21043 }
21044
21045
21046 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21047 PyObject *resultobj = 0;
21048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21049 bool result;
21050 void *argp1 = 0 ;
21051 int res1 = 0 ;
21052 PyObject *swig_obj[1] ;
21053
21054 if (!args) SWIG_fail;
21055 swig_obj[0] = args;
21056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21057 if (!SWIG_IsOK(res1)) {
21058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21059 }
21060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 {
21068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21069 }
21070 return resultobj;
21071 fail:
21072 return NULL;
21073 }
21074
21075
21076 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21077 PyObject *resultobj = 0;
21078 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21079 int arg2 ;
21080 void *argp1 = 0 ;
21081 int res1 = 0 ;
21082 int val2 ;
21083 int ecode2 = 0 ;
21084 PyObject *swig_obj[2] ;
21085
21086 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21090 }
21091 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21092 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21093 if (!SWIG_IsOK(ecode2)) {
21094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21095 }
21096 arg2 = static_cast< int >(val2);
21097 if (arg1) (arg1)->m_x = arg2;
21098
21099 resultobj = SWIG_Py_Void();
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21107 PyObject *resultobj = 0;
21108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21109 int result;
21110 void *argp1 = 0 ;
21111 int res1 = 0 ;
21112 PyObject *swig_obj[1] ;
21113
21114 if (!args) SWIG_fail;
21115 swig_obj[0] = args;
21116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21117 if (!SWIG_IsOK(res1)) {
21118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21119 }
21120 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21121 result = (int) ((arg1)->m_x);
21122 resultobj = SWIG_From_int(static_cast< int >(result));
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 PyObject *resultobj = 0;
21131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21132 int arg2 ;
21133 void *argp1 = 0 ;
21134 int res1 = 0 ;
21135 int val2 ;
21136 int ecode2 = 0 ;
21137 PyObject *swig_obj[2] ;
21138
21139 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21141 if (!SWIG_IsOK(res1)) {
21142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21143 }
21144 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21145 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21146 if (!SWIG_IsOK(ecode2)) {
21147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21148 }
21149 arg2 = static_cast< int >(val2);
21150 if (arg1) (arg1)->m_y = arg2;
21151
21152 resultobj = SWIG_Py_Void();
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21160 PyObject *resultobj = 0;
21161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21162 int result;
21163 void *argp1 = 0 ;
21164 int res1 = 0 ;
21165 PyObject *swig_obj[1] ;
21166
21167 if (!args) SWIG_fail;
21168 swig_obj[0] = args;
21169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21172 }
21173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21174 result = (int) ((arg1)->m_y);
21175 resultobj = SWIG_From_int(static_cast< int >(result));
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 PyObject *resultobj = 0;
21184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21185 bool arg2 ;
21186 void *argp1 = 0 ;
21187 int res1 = 0 ;
21188 bool val2 ;
21189 int ecode2 = 0 ;
21190 PyObject *swig_obj[2] ;
21191
21192 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21194 if (!SWIG_IsOK(res1)) {
21195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21196 }
21197 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21198 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21199 if (!SWIG_IsOK(ecode2)) {
21200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21201 }
21202 arg2 = static_cast< bool >(val2);
21203 if (arg1) (arg1)->m_leftDown = arg2;
21204
21205 resultobj = SWIG_Py_Void();
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 PyObject *resultobj = 0;
21214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21215 bool result;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 PyObject *swig_obj[1] ;
21219
21220 if (!args) SWIG_fail;
21221 swig_obj[0] = args;
21222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21223 if (!SWIG_IsOK(res1)) {
21224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21225 }
21226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21227 result = (bool) ((arg1)->m_leftDown);
21228 {
21229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21230 }
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21238 PyObject *resultobj = 0;
21239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21240 bool arg2 ;
21241 void *argp1 = 0 ;
21242 int res1 = 0 ;
21243 bool val2 ;
21244 int ecode2 = 0 ;
21245 PyObject *swig_obj[2] ;
21246
21247 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21249 if (!SWIG_IsOK(res1)) {
21250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21251 }
21252 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21253 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21254 if (!SWIG_IsOK(ecode2)) {
21255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21256 }
21257 arg2 = static_cast< bool >(val2);
21258 if (arg1) (arg1)->m_middleDown = arg2;
21259
21260 resultobj = SWIG_Py_Void();
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21268 PyObject *resultobj = 0;
21269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21270 bool result;
21271 void *argp1 = 0 ;
21272 int res1 = 0 ;
21273 PyObject *swig_obj[1] ;
21274
21275 if (!args) SWIG_fail;
21276 swig_obj[0] = args;
21277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21278 if (!SWIG_IsOK(res1)) {
21279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21280 }
21281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21282 result = (bool) ((arg1)->m_middleDown);
21283 {
21284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21285 }
21286 return resultobj;
21287 fail:
21288 return NULL;
21289 }
21290
21291
21292 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21293 PyObject *resultobj = 0;
21294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21295 bool arg2 ;
21296 void *argp1 = 0 ;
21297 int res1 = 0 ;
21298 bool val2 ;
21299 int ecode2 = 0 ;
21300 PyObject *swig_obj[2] ;
21301
21302 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21304 if (!SWIG_IsOK(res1)) {
21305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21306 }
21307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21308 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21309 if (!SWIG_IsOK(ecode2)) {
21310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21311 }
21312 arg2 = static_cast< bool >(val2);
21313 if (arg1) (arg1)->m_rightDown = arg2;
21314
21315 resultobj = SWIG_Py_Void();
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21323 PyObject *resultobj = 0;
21324 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21325 bool result;
21326 void *argp1 = 0 ;
21327 int res1 = 0 ;
21328 PyObject *swig_obj[1] ;
21329
21330 if (!args) SWIG_fail;
21331 swig_obj[0] = args;
21332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21333 if (!SWIG_IsOK(res1)) {
21334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21335 }
21336 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21337 result = (bool) ((arg1)->m_rightDown);
21338 {
21339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21340 }
21341 return resultobj;
21342 fail:
21343 return NULL;
21344 }
21345
21346
21347 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21348 PyObject *resultobj = 0;
21349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21350 bool arg2 ;
21351 void *argp1 = 0 ;
21352 int res1 = 0 ;
21353 bool val2 ;
21354 int ecode2 = 0 ;
21355 PyObject *swig_obj[2] ;
21356
21357 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21359 if (!SWIG_IsOK(res1)) {
21360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21361 }
21362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21363 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21364 if (!SWIG_IsOK(ecode2)) {
21365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21366 }
21367 arg2 = static_cast< bool >(val2);
21368 if (arg1) (arg1)->m_controlDown = arg2;
21369
21370 resultobj = SWIG_Py_Void();
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21380 bool result;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 PyObject *swig_obj[1] ;
21384
21385 if (!args) SWIG_fail;
21386 swig_obj[0] = args;
21387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21390 }
21391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21392 result = (bool) ((arg1)->m_controlDown);
21393 {
21394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21395 }
21396 return resultobj;
21397 fail:
21398 return NULL;
21399 }
21400
21401
21402 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21403 PyObject *resultobj = 0;
21404 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21405 bool arg2 ;
21406 void *argp1 = 0 ;
21407 int res1 = 0 ;
21408 bool val2 ;
21409 int ecode2 = 0 ;
21410 PyObject *swig_obj[2] ;
21411
21412 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21414 if (!SWIG_IsOK(res1)) {
21415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21416 }
21417 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21418 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21419 if (!SWIG_IsOK(ecode2)) {
21420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21421 }
21422 arg2 = static_cast< bool >(val2);
21423 if (arg1) (arg1)->m_shiftDown = arg2;
21424
21425 resultobj = SWIG_Py_Void();
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21433 PyObject *resultobj = 0;
21434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21435 bool result;
21436 void *argp1 = 0 ;
21437 int res1 = 0 ;
21438 PyObject *swig_obj[1] ;
21439
21440 if (!args) SWIG_fail;
21441 swig_obj[0] = args;
21442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21445 }
21446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21447 result = (bool) ((arg1)->m_shiftDown);
21448 {
21449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21450 }
21451 return resultobj;
21452 fail:
21453 return NULL;
21454 }
21455
21456
21457 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21458 PyObject *resultobj = 0;
21459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21460 bool arg2 ;
21461 void *argp1 = 0 ;
21462 int res1 = 0 ;
21463 bool val2 ;
21464 int ecode2 = 0 ;
21465 PyObject *swig_obj[2] ;
21466
21467 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21469 if (!SWIG_IsOK(res1)) {
21470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21471 }
21472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21473 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21474 if (!SWIG_IsOK(ecode2)) {
21475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21476 }
21477 arg2 = static_cast< bool >(val2);
21478 if (arg1) (arg1)->m_altDown = arg2;
21479
21480 resultobj = SWIG_Py_Void();
21481 return resultobj;
21482 fail:
21483 return NULL;
21484 }
21485
21486
21487 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21488 PyObject *resultobj = 0;
21489 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21490 bool result;
21491 void *argp1 = 0 ;
21492 int res1 = 0 ;
21493 PyObject *swig_obj[1] ;
21494
21495 if (!args) SWIG_fail;
21496 swig_obj[0] = args;
21497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21498 if (!SWIG_IsOK(res1)) {
21499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21500 }
21501 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21502 result = (bool) ((arg1)->m_altDown);
21503 {
21504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21505 }
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21513 PyObject *resultobj = 0;
21514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21515 bool arg2 ;
21516 void *argp1 = 0 ;
21517 int res1 = 0 ;
21518 bool val2 ;
21519 int ecode2 = 0 ;
21520 PyObject *swig_obj[2] ;
21521
21522 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21524 if (!SWIG_IsOK(res1)) {
21525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21526 }
21527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21528 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21529 if (!SWIG_IsOK(ecode2)) {
21530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21531 }
21532 arg2 = static_cast< bool >(val2);
21533 if (arg1) (arg1)->m_metaDown = arg2;
21534
21535 resultobj = SWIG_Py_Void();
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21543 PyObject *resultobj = 0;
21544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21545 bool result;
21546 void *argp1 = 0 ;
21547 int res1 = 0 ;
21548 PyObject *swig_obj[1] ;
21549
21550 if (!args) SWIG_fail;
21551 swig_obj[0] = args;
21552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21553 if (!SWIG_IsOK(res1)) {
21554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21555 }
21556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21557 result = (bool) ((arg1)->m_metaDown);
21558 {
21559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21560 }
21561 return resultobj;
21562 fail:
21563 return NULL;
21564 }
21565
21566
21567 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21568 PyObject *resultobj = 0;
21569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21570 int arg2 ;
21571 void *argp1 = 0 ;
21572 int res1 = 0 ;
21573 int val2 ;
21574 int ecode2 = 0 ;
21575 PyObject *swig_obj[2] ;
21576
21577 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21579 if (!SWIG_IsOK(res1)) {
21580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21581 }
21582 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21583 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21584 if (!SWIG_IsOK(ecode2)) {
21585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21586 }
21587 arg2 = static_cast< int >(val2);
21588 if (arg1) (arg1)->m_wheelRotation = arg2;
21589
21590 resultobj = SWIG_Py_Void();
21591 return resultobj;
21592 fail:
21593 return NULL;
21594 }
21595
21596
21597 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21598 PyObject *resultobj = 0;
21599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21600 int result;
21601 void *argp1 = 0 ;
21602 int res1 = 0 ;
21603 PyObject *swig_obj[1] ;
21604
21605 if (!args) SWIG_fail;
21606 swig_obj[0] = args;
21607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21608 if (!SWIG_IsOK(res1)) {
21609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21610 }
21611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21612 result = (int) ((arg1)->m_wheelRotation);
21613 resultobj = SWIG_From_int(static_cast< int >(result));
21614 return resultobj;
21615 fail:
21616 return NULL;
21617 }
21618
21619
21620 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21621 PyObject *resultobj = 0;
21622 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21623 int arg2 ;
21624 void *argp1 = 0 ;
21625 int res1 = 0 ;
21626 int val2 ;
21627 int ecode2 = 0 ;
21628 PyObject *swig_obj[2] ;
21629
21630 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21632 if (!SWIG_IsOK(res1)) {
21633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21634 }
21635 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21636 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21637 if (!SWIG_IsOK(ecode2)) {
21638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21639 }
21640 arg2 = static_cast< int >(val2);
21641 if (arg1) (arg1)->m_wheelDelta = arg2;
21642
21643 resultobj = SWIG_Py_Void();
21644 return resultobj;
21645 fail:
21646 return NULL;
21647 }
21648
21649
21650 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21651 PyObject *resultobj = 0;
21652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21653 int result;
21654 void *argp1 = 0 ;
21655 int res1 = 0 ;
21656 PyObject *swig_obj[1] ;
21657
21658 if (!args) SWIG_fail;
21659 swig_obj[0] = args;
21660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21661 if (!SWIG_IsOK(res1)) {
21662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21663 }
21664 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21665 result = (int) ((arg1)->m_wheelDelta);
21666 resultobj = SWIG_From_int(static_cast< int >(result));
21667 return resultobj;
21668 fail:
21669 return NULL;
21670 }
21671
21672
21673 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 PyObject *resultobj = 0;
21675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21676 int arg2 ;
21677 void *argp1 = 0 ;
21678 int res1 = 0 ;
21679 int val2 ;
21680 int ecode2 = 0 ;
21681 PyObject *swig_obj[2] ;
21682
21683 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21685 if (!SWIG_IsOK(res1)) {
21686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21687 }
21688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21689 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21690 if (!SWIG_IsOK(ecode2)) {
21691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21692 }
21693 arg2 = static_cast< int >(val2);
21694 if (arg1) (arg1)->m_linesPerAction = arg2;
21695
21696 resultobj = SWIG_Py_Void();
21697 return resultobj;
21698 fail:
21699 return NULL;
21700 }
21701
21702
21703 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21704 PyObject *resultobj = 0;
21705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21706 int result;
21707 void *argp1 = 0 ;
21708 int res1 = 0 ;
21709 PyObject *swig_obj[1] ;
21710
21711 if (!args) SWIG_fail;
21712 swig_obj[0] = args;
21713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21714 if (!SWIG_IsOK(res1)) {
21715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21716 }
21717 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21718 result = (int) ((arg1)->m_linesPerAction);
21719 resultobj = SWIG_From_int(static_cast< int >(result));
21720 return resultobj;
21721 fail:
21722 return NULL;
21723 }
21724
21725
21726 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21727 PyObject *obj;
21728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21729 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21730 return SWIG_Py_Void();
21731 }
21732
21733 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21734 return SWIG_Python_InitShadowInstance(args);
21735 }
21736
21737 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21738 PyObject *resultobj = 0;
21739 int arg1 = (int) 0 ;
21740 int arg2 = (int) 0 ;
21741 wxSetCursorEvent *result = 0 ;
21742 int val1 ;
21743 int ecode1 = 0 ;
21744 int val2 ;
21745 int ecode2 = 0 ;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 char * kwnames[] = {
21749 (char *) "x",(char *) "y", NULL
21750 };
21751
21752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21753 if (obj0) {
21754 ecode1 = SWIG_AsVal_int(obj0, &val1);
21755 if (!SWIG_IsOK(ecode1)) {
21756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21757 }
21758 arg1 = static_cast< int >(val1);
21759 }
21760 if (obj1) {
21761 ecode2 = SWIG_AsVal_int(obj1, &val2);
21762 if (!SWIG_IsOK(ecode2)) {
21763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21764 }
21765 arg2 = static_cast< int >(val2);
21766 }
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21781 PyObject *resultobj = 0;
21782 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21783 int result;
21784 void *argp1 = 0 ;
21785 int res1 = 0 ;
21786 PyObject *swig_obj[1] ;
21787
21788 if (!args) SWIG_fail;
21789 swig_obj[0] = args;
21790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21791 if (!SWIG_IsOK(res1)) {
21792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21793 }
21794 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21795 {
21796 PyThreadState* __tstate = wxPyBeginAllowThreads();
21797 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 resultobj = SWIG_From_int(static_cast< int >(result));
21802 return resultobj;
21803 fail:
21804 return NULL;
21805 }
21806
21807
21808 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21809 PyObject *resultobj = 0;
21810 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21811 int result;
21812 void *argp1 = 0 ;
21813 int res1 = 0 ;
21814 PyObject *swig_obj[1] ;
21815
21816 if (!args) SWIG_fail;
21817 swig_obj[0] = args;
21818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21819 if (!SWIG_IsOK(res1)) {
21820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21821 }
21822 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21823 {
21824 PyThreadState* __tstate = wxPyBeginAllowThreads();
21825 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21826 wxPyEndAllowThreads(__tstate);
21827 if (PyErr_Occurred()) SWIG_fail;
21828 }
21829 resultobj = SWIG_From_int(static_cast< int >(result));
21830 return resultobj;
21831 fail:
21832 return NULL;
21833 }
21834
21835
21836 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21837 PyObject *resultobj = 0;
21838 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21839 wxCursor *arg2 = 0 ;
21840 void *argp1 = 0 ;
21841 int res1 = 0 ;
21842 void *argp2 = 0 ;
21843 int res2 = 0 ;
21844 PyObject * obj0 = 0 ;
21845 PyObject * obj1 = 0 ;
21846 char * kwnames[] = {
21847 (char *) "self",(char *) "cursor", NULL
21848 };
21849
21850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21852 if (!SWIG_IsOK(res1)) {
21853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21854 }
21855 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21857 if (!SWIG_IsOK(res2)) {
21858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21859 }
21860 if (!argp2) {
21861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21862 }
21863 arg2 = reinterpret_cast< wxCursor * >(argp2);
21864 {
21865 PyThreadState* __tstate = wxPyBeginAllowThreads();
21866 (arg1)->SetCursor((wxCursor const &)*arg2);
21867 wxPyEndAllowThreads(__tstate);
21868 if (PyErr_Occurred()) SWIG_fail;
21869 }
21870 resultobj = SWIG_Py_Void();
21871 return resultobj;
21872 fail:
21873 return NULL;
21874 }
21875
21876
21877 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21878 PyObject *resultobj = 0;
21879 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21880 wxCursor *result = 0 ;
21881 void *argp1 = 0 ;
21882 int res1 = 0 ;
21883 PyObject *swig_obj[1] ;
21884
21885 if (!args) SWIG_fail;
21886 swig_obj[0] = args;
21887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21888 if (!SWIG_IsOK(res1)) {
21889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21890 }
21891 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21892 {
21893 PyThreadState* __tstate = wxPyBeginAllowThreads();
21894 {
21895 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21896 result = (wxCursor *) &_result_ref;
21897 }
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 {
21902 wxCursor* resultptr = new wxCursor(*result);
21903 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21904 }
21905 return resultobj;
21906 fail:
21907 return NULL;
21908 }
21909
21910
21911 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21912 PyObject *resultobj = 0;
21913 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21914 bool result;
21915 void *argp1 = 0 ;
21916 int res1 = 0 ;
21917 PyObject *swig_obj[1] ;
21918
21919 if (!args) SWIG_fail;
21920 swig_obj[0] = args;
21921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21922 if (!SWIG_IsOK(res1)) {
21923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21924 }
21925 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 {
21933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21934 }
21935 return resultobj;
21936 fail:
21937 return NULL;
21938 }
21939
21940
21941 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21942 PyObject *obj;
21943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21944 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21945 return SWIG_Py_Void();
21946 }
21947
21948 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21949 return SWIG_Python_InitShadowInstance(args);
21950 }
21951
21952 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21953 PyObject *resultobj = 0;
21954 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21955 wxKeyEvent *result = 0 ;
21956 int val1 ;
21957 int ecode1 = 0 ;
21958 PyObject * obj0 = 0 ;
21959 char * kwnames[] = {
21960 (char *) "eventType", NULL
21961 };
21962
21963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21964 if (obj0) {
21965 ecode1 = SWIG_AsVal_int(obj0, &val1);
21966 if (!SWIG_IsOK(ecode1)) {
21967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21968 }
21969 arg1 = static_cast< wxEventType >(val1);
21970 }
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985 PyObject *resultobj = 0;
21986 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21987 int result;
21988 void *argp1 = 0 ;
21989 int res1 = 0 ;
21990 PyObject *swig_obj[1] ;
21991
21992 if (!args) SWIG_fail;
21993 swig_obj[0] = args;
21994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21995 if (!SWIG_IsOK(res1)) {
21996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21997 }
21998 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 resultobj = SWIG_From_int(static_cast< int >(result));
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22013 PyObject *resultobj = 0;
22014 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22015 bool result;
22016 void *argp1 = 0 ;
22017 int res1 = 0 ;
22018 PyObject *swig_obj[1] ;
22019
22020 if (!args) SWIG_fail;
22021 swig_obj[0] = args;
22022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22023 if (!SWIG_IsOK(res1)) {
22024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22025 }
22026 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22027 {
22028 PyThreadState* __tstate = wxPyBeginAllowThreads();
22029 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 {
22034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22035 }
22036 return resultobj;
22037 fail:
22038 return NULL;
22039 }
22040
22041
22042 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22043 PyObject *resultobj = 0;
22044 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22045 bool result;
22046 void *argp1 = 0 ;
22047 int res1 = 0 ;
22048 PyObject *swig_obj[1] ;
22049
22050 if (!args) SWIG_fail;
22051 swig_obj[0] = args;
22052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22053 if (!SWIG_IsOK(res1)) {
22054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22055 }
22056 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22060 wxPyEndAllowThreads(__tstate);
22061 if (PyErr_Occurred()) SWIG_fail;
22062 }
22063 {
22064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22065 }
22066 return resultobj;
22067 fail:
22068 return NULL;
22069 }
22070
22071
22072 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22073 PyObject *resultobj = 0;
22074 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22075 bool result;
22076 void *argp1 = 0 ;
22077 int res1 = 0 ;
22078 PyObject *swig_obj[1] ;
22079
22080 if (!args) SWIG_fail;
22081 swig_obj[0] = args;
22082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22083 if (!SWIG_IsOK(res1)) {
22084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22085 }
22086 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22090 wxPyEndAllowThreads(__tstate);
22091 if (PyErr_Occurred()) SWIG_fail;
22092 }
22093 {
22094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22095 }
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22103 PyObject *resultobj = 0;
22104 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22105 bool result;
22106 void *argp1 = 0 ;
22107 int res1 = 0 ;
22108 PyObject *swig_obj[1] ;
22109
22110 if (!args) SWIG_fail;
22111 swig_obj[0] = args;
22112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22113 if (!SWIG_IsOK(res1)) {
22114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22115 }
22116 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22117 {
22118 PyThreadState* __tstate = wxPyBeginAllowThreads();
22119 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22120 wxPyEndAllowThreads(__tstate);
22121 if (PyErr_Occurred()) SWIG_fail;
22122 }
22123 {
22124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22125 }
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22133 PyObject *resultobj = 0;
22134 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22135 bool result;
22136 void *argp1 = 0 ;
22137 int res1 = 0 ;
22138 PyObject *swig_obj[1] ;
22139
22140 if (!args) SWIG_fail;
22141 swig_obj[0] = args;
22142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22145 }
22146 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22150 wxPyEndAllowThreads(__tstate);
22151 if (PyErr_Occurred()) SWIG_fail;
22152 }
22153 {
22154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22155 }
22156 return resultobj;
22157 fail:
22158 return NULL;
22159 }
22160
22161
22162 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22163 PyObject *resultobj = 0;
22164 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22165 bool result;
22166 void *argp1 = 0 ;
22167 int res1 = 0 ;
22168 PyObject *swig_obj[1] ;
22169
22170 if (!args) SWIG_fail;
22171 swig_obj[0] = args;
22172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22173 if (!SWIG_IsOK(res1)) {
22174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22175 }
22176 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22180 wxPyEndAllowThreads(__tstate);
22181 if (PyErr_Occurred()) SWIG_fail;
22182 }
22183 {
22184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22185 }
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22193 PyObject *resultobj = 0;
22194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22195 int result;
22196 void *argp1 = 0 ;
22197 int res1 = 0 ;
22198 PyObject *swig_obj[1] ;
22199
22200 if (!args) SWIG_fail;
22201 swig_obj[0] = args;
22202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22203 if (!SWIG_IsOK(res1)) {
22204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22205 }
22206 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 resultobj = SWIG_From_int(static_cast< int >(result));
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22223 int result;
22224 void *argp1 = 0 ;
22225 int res1 = 0 ;
22226 PyObject *swig_obj[1] ;
22227
22228 if (!args) SWIG_fail;
22229 swig_obj[0] = args;
22230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22231 if (!SWIG_IsOK(res1)) {
22232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22233 }
22234 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22235 {
22236 PyThreadState* __tstate = wxPyBeginAllowThreads();
22237 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 resultobj = SWIG_From_int(static_cast< int >(result));
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj = 0;
22250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22251 int arg2 ;
22252 void *argp1 = 0 ;
22253 int res1 = 0 ;
22254 int val2 ;
22255 int ecode2 = 0 ;
22256 PyObject * obj0 = 0 ;
22257 PyObject * obj1 = 0 ;
22258 char * kwnames[] = {
22259 (char *) "self",(char *) "uniChar", NULL
22260 };
22261
22262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22266 }
22267 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22268 ecode2 = SWIG_AsVal_int(obj1, &val2);
22269 if (!SWIG_IsOK(ecode2)) {
22270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22271 }
22272 arg2 = static_cast< int >(val2);
22273 {
22274 PyThreadState* __tstate = wxPyBeginAllowThreads();
22275 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22276 wxPyEndAllowThreads(__tstate);
22277 if (PyErr_Occurred()) SWIG_fail;
22278 }
22279 resultobj = SWIG_Py_Void();
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22287 PyObject *resultobj = 0;
22288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22289 unsigned int result;
22290 void *argp1 = 0 ;
22291 int res1 = 0 ;
22292 PyObject *swig_obj[1] ;
22293
22294 if (!args) SWIG_fail;
22295 swig_obj[0] = args;
22296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22297 if (!SWIG_IsOK(res1)) {
22298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22299 }
22300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22315 PyObject *resultobj = 0;
22316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22317 unsigned int result;
22318 void *argp1 = 0 ;
22319 int res1 = 0 ;
22320 PyObject *swig_obj[1] ;
22321
22322 if (!args) SWIG_fail;
22323 swig_obj[0] = args;
22324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22325 if (!SWIG_IsOK(res1)) {
22326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22327 }
22328 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22329 {
22330 PyThreadState* __tstate = wxPyBeginAllowThreads();
22331 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22336 return resultobj;
22337 fail:
22338 return NULL;
22339 }
22340
22341
22342 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22343 PyObject *resultobj = 0;
22344 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22345 wxPoint result;
22346 void *argp1 = 0 ;
22347 int res1 = 0 ;
22348 PyObject *swig_obj[1] ;
22349
22350 if (!args) SWIG_fail;
22351 swig_obj[0] = args;
22352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22353 if (!SWIG_IsOK(res1)) {
22354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22355 }
22356 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22357 {
22358 PyThreadState* __tstate = wxPyBeginAllowThreads();
22359 result = (arg1)->GetPosition();
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22371 PyObject *resultobj = 0;
22372 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22373 long *arg2 = (long *) 0 ;
22374 long *arg3 = (long *) 0 ;
22375 void *argp1 = 0 ;
22376 int res1 = 0 ;
22377 long temp2 ;
22378 int res2 = SWIG_TMPOBJ ;
22379 long temp3 ;
22380 int res3 = SWIG_TMPOBJ ;
22381 PyObject *swig_obj[1] ;
22382
22383 arg2 = &temp2;
22384 arg3 = &temp3;
22385 if (!args) SWIG_fail;
22386 swig_obj[0] = args;
22387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22388 if (!SWIG_IsOK(res1)) {
22389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22390 }
22391 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22392 {
22393 PyThreadState* __tstate = wxPyBeginAllowThreads();
22394 (arg1)->GetPosition(arg2,arg3);
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 resultobj = SWIG_Py_Void();
22399 if (SWIG_IsTmpObj(res2)) {
22400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22401 } else {
22402 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22404 }
22405 if (SWIG_IsTmpObj(res3)) {
22406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22407 } else {
22408 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22410 }
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22418 PyObject *resultobj = 0;
22419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22420 int result;
22421 void *argp1 = 0 ;
22422 int res1 = 0 ;
22423 PyObject *swig_obj[1] ;
22424
22425 if (!args) SWIG_fail;
22426 swig_obj[0] = args;
22427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22428 if (!SWIG_IsOK(res1)) {
22429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22430 }
22431 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = (int)((wxKeyEvent const *)arg1)->GetX();
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 resultobj = SWIG_From_int(static_cast< int >(result));
22439 return resultobj;
22440 fail:
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22448 int result;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 PyObject *swig_obj[1] ;
22452
22453 if (!args) SWIG_fail;
22454 swig_obj[0] = args;
22455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22456 if (!SWIG_IsOK(res1)) {
22457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22458 }
22459 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22460 {
22461 PyThreadState* __tstate = wxPyBeginAllowThreads();
22462 result = (int)((wxKeyEvent const *)arg1)->GetY();
22463 wxPyEndAllowThreads(__tstate);
22464 if (PyErr_Occurred()) SWIG_fail;
22465 }
22466 resultobj = SWIG_From_int(static_cast< int >(result));
22467 return resultobj;
22468 fail:
22469 return NULL;
22470 }
22471
22472
22473 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22474 PyObject *resultobj = 0;
22475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22476 int arg2 ;
22477 void *argp1 = 0 ;
22478 int res1 = 0 ;
22479 int val2 ;
22480 int ecode2 = 0 ;
22481 PyObject *swig_obj[2] ;
22482
22483 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22485 if (!SWIG_IsOK(res1)) {
22486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22487 }
22488 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22489 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22490 if (!SWIG_IsOK(ecode2)) {
22491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22492 }
22493 arg2 = static_cast< int >(val2);
22494 if (arg1) (arg1)->m_x = arg2;
22495
22496 resultobj = SWIG_Py_Void();
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22504 PyObject *resultobj = 0;
22505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22506 int result;
22507 void *argp1 = 0 ;
22508 int res1 = 0 ;
22509 PyObject *swig_obj[1] ;
22510
22511 if (!args) SWIG_fail;
22512 swig_obj[0] = args;
22513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22514 if (!SWIG_IsOK(res1)) {
22515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22516 }
22517 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22518 result = (int) ((arg1)->m_x);
22519 resultobj = SWIG_From_int(static_cast< int >(result));
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22527 PyObject *resultobj = 0;
22528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22529 int arg2 ;
22530 void *argp1 = 0 ;
22531 int res1 = 0 ;
22532 int val2 ;
22533 int ecode2 = 0 ;
22534 PyObject *swig_obj[2] ;
22535
22536 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22543 if (!SWIG_IsOK(ecode2)) {
22544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22545 }
22546 arg2 = static_cast< int >(val2);
22547 if (arg1) (arg1)->m_y = arg2;
22548
22549 resultobj = SWIG_Py_Void();
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22557 PyObject *resultobj = 0;
22558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22559 int result;
22560 void *argp1 = 0 ;
22561 int res1 = 0 ;
22562 PyObject *swig_obj[1] ;
22563
22564 if (!args) SWIG_fail;
22565 swig_obj[0] = args;
22566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22567 if (!SWIG_IsOK(res1)) {
22568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22569 }
22570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22571 result = (int) ((arg1)->m_y);
22572 resultobj = SWIG_From_int(static_cast< int >(result));
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *resultobj = 0;
22581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22582 long arg2 ;
22583 void *argp1 = 0 ;
22584 int res1 = 0 ;
22585 long val2 ;
22586 int ecode2 = 0 ;
22587 PyObject *swig_obj[2] ;
22588
22589 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22591 if (!SWIG_IsOK(res1)) {
22592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22593 }
22594 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22595 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22596 if (!SWIG_IsOK(ecode2)) {
22597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22598 }
22599 arg2 = static_cast< long >(val2);
22600 if (arg1) (arg1)->m_keyCode = arg2;
22601
22602 resultobj = SWIG_Py_Void();
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22610 PyObject *resultobj = 0;
22611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22612 long result;
22613 void *argp1 = 0 ;
22614 int res1 = 0 ;
22615 PyObject *swig_obj[1] ;
22616
22617 if (!args) SWIG_fail;
22618 swig_obj[0] = args;
22619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22620 if (!SWIG_IsOK(res1)) {
22621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22622 }
22623 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22624 result = (long) ((arg1)->m_keyCode);
22625 resultobj = SWIG_From_long(static_cast< long >(result));
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22633 PyObject *resultobj = 0;
22634 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22635 bool arg2 ;
22636 void *argp1 = 0 ;
22637 int res1 = 0 ;
22638 bool val2 ;
22639 int ecode2 = 0 ;
22640 PyObject *swig_obj[2] ;
22641
22642 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22644 if (!SWIG_IsOK(res1)) {
22645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22646 }
22647 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22648 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22649 if (!SWIG_IsOK(ecode2)) {
22650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22651 }
22652 arg2 = static_cast< bool >(val2);
22653 if (arg1) (arg1)->m_controlDown = arg2;
22654
22655 resultobj = SWIG_Py_Void();
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22665 bool result;
22666 void *argp1 = 0 ;
22667 int res1 = 0 ;
22668 PyObject *swig_obj[1] ;
22669
22670 if (!args) SWIG_fail;
22671 swig_obj[0] = args;
22672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22673 if (!SWIG_IsOK(res1)) {
22674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22675 }
22676 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22677 result = (bool) ((arg1)->m_controlDown);
22678 {
22679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22680 }
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22688 PyObject *resultobj = 0;
22689 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22690 bool arg2 ;
22691 void *argp1 = 0 ;
22692 int res1 = 0 ;
22693 bool val2 ;
22694 int ecode2 = 0 ;
22695 PyObject *swig_obj[2] ;
22696
22697 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22699 if (!SWIG_IsOK(res1)) {
22700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22701 }
22702 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22703 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22704 if (!SWIG_IsOK(ecode2)) {
22705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22706 }
22707 arg2 = static_cast< bool >(val2);
22708 if (arg1) (arg1)->m_shiftDown = arg2;
22709
22710 resultobj = SWIG_Py_Void();
22711 return resultobj;
22712 fail:
22713 return NULL;
22714 }
22715
22716
22717 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22718 PyObject *resultobj = 0;
22719 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22720 bool result;
22721 void *argp1 = 0 ;
22722 int res1 = 0 ;
22723 PyObject *swig_obj[1] ;
22724
22725 if (!args) SWIG_fail;
22726 swig_obj[0] = args;
22727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22732 result = (bool) ((arg1)->m_shiftDown);
22733 {
22734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22735 }
22736 return resultobj;
22737 fail:
22738 return NULL;
22739 }
22740
22741
22742 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22743 PyObject *resultobj = 0;
22744 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22745 bool arg2 ;
22746 void *argp1 = 0 ;
22747 int res1 = 0 ;
22748 bool val2 ;
22749 int ecode2 = 0 ;
22750 PyObject *swig_obj[2] ;
22751
22752 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22754 if (!SWIG_IsOK(res1)) {
22755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22756 }
22757 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22758 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22759 if (!SWIG_IsOK(ecode2)) {
22760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22761 }
22762 arg2 = static_cast< bool >(val2);
22763 if (arg1) (arg1)->m_altDown = arg2;
22764
22765 resultobj = SWIG_Py_Void();
22766 return resultobj;
22767 fail:
22768 return NULL;
22769 }
22770
22771
22772 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22773 PyObject *resultobj = 0;
22774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22775 bool result;
22776 void *argp1 = 0 ;
22777 int res1 = 0 ;
22778 PyObject *swig_obj[1] ;
22779
22780 if (!args) SWIG_fail;
22781 swig_obj[0] = args;
22782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22783 if (!SWIG_IsOK(res1)) {
22784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22785 }
22786 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22787 result = (bool) ((arg1)->m_altDown);
22788 {
22789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22790 }
22791 return resultobj;
22792 fail:
22793 return NULL;
22794 }
22795
22796
22797 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22798 PyObject *resultobj = 0;
22799 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22800 bool arg2 ;
22801 void *argp1 = 0 ;
22802 int res1 = 0 ;
22803 bool val2 ;
22804 int ecode2 = 0 ;
22805 PyObject *swig_obj[2] ;
22806
22807 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22809 if (!SWIG_IsOK(res1)) {
22810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22811 }
22812 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22813 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22814 if (!SWIG_IsOK(ecode2)) {
22815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22816 }
22817 arg2 = static_cast< bool >(val2);
22818 if (arg1) (arg1)->m_metaDown = arg2;
22819
22820 resultobj = SWIG_Py_Void();
22821 return resultobj;
22822 fail:
22823 return NULL;
22824 }
22825
22826
22827 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22828 PyObject *resultobj = 0;
22829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22830 bool result;
22831 void *argp1 = 0 ;
22832 int res1 = 0 ;
22833 PyObject *swig_obj[1] ;
22834
22835 if (!args) SWIG_fail;
22836 swig_obj[0] = args;
22837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22842 result = (bool) ((arg1)->m_metaDown);
22843 {
22844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22845 }
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22853 PyObject *resultobj = 0;
22854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22855 bool arg2 ;
22856 void *argp1 = 0 ;
22857 int res1 = 0 ;
22858 bool val2 ;
22859 int ecode2 = 0 ;
22860 PyObject *swig_obj[2] ;
22861
22862 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22864 if (!SWIG_IsOK(res1)) {
22865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22866 }
22867 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22868 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22869 if (!SWIG_IsOK(ecode2)) {
22870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22871 }
22872 arg2 = static_cast< bool >(val2);
22873 if (arg1) (arg1)->m_scanCode = arg2;
22874
22875 resultobj = SWIG_Py_Void();
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22883 PyObject *resultobj = 0;
22884 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22885 bool result;
22886 void *argp1 = 0 ;
22887 int res1 = 0 ;
22888 PyObject *swig_obj[1] ;
22889
22890 if (!args) SWIG_fail;
22891 swig_obj[0] = args;
22892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22893 if (!SWIG_IsOK(res1)) {
22894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22895 }
22896 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22897 result = (bool) ((arg1)->m_scanCode);
22898 {
22899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22908 PyObject *resultobj = 0;
22909 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22910 unsigned int arg2 ;
22911 void *argp1 = 0 ;
22912 int res1 = 0 ;
22913 unsigned int val2 ;
22914 int ecode2 = 0 ;
22915 PyObject *swig_obj[2] ;
22916
22917 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22919 if (!SWIG_IsOK(res1)) {
22920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22921 }
22922 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22923 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22924 if (!SWIG_IsOK(ecode2)) {
22925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22926 }
22927 arg2 = static_cast< unsigned int >(val2);
22928 if (arg1) (arg1)->m_rawCode = arg2;
22929
22930 resultobj = SWIG_Py_Void();
22931 return resultobj;
22932 fail:
22933 return NULL;
22934 }
22935
22936
22937 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22938 PyObject *resultobj = 0;
22939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22940 unsigned int result;
22941 void *argp1 = 0 ;
22942 int res1 = 0 ;
22943 PyObject *swig_obj[1] ;
22944
22945 if (!args) SWIG_fail;
22946 swig_obj[0] = args;
22947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22948 if (!SWIG_IsOK(res1)) {
22949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22950 }
22951 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22952 result = (unsigned int) ((arg1)->m_rawCode);
22953 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22961 PyObject *resultobj = 0;
22962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22963 unsigned int arg2 ;
22964 void *argp1 = 0 ;
22965 int res1 = 0 ;
22966 unsigned int val2 ;
22967 int ecode2 = 0 ;
22968 PyObject *swig_obj[2] ;
22969
22970 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22972 if (!SWIG_IsOK(res1)) {
22973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22974 }
22975 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22976 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22977 if (!SWIG_IsOK(ecode2)) {
22978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22979 }
22980 arg2 = static_cast< unsigned int >(val2);
22981 if (arg1) (arg1)->m_rawFlags = arg2;
22982
22983 resultobj = SWIG_Py_Void();
22984 return resultobj;
22985 fail:
22986 return NULL;
22987 }
22988
22989
22990 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22991 PyObject *resultobj = 0;
22992 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22993 unsigned int result;
22994 void *argp1 = 0 ;
22995 int res1 = 0 ;
22996 PyObject *swig_obj[1] ;
22997
22998 if (!args) SWIG_fail;
22999 swig_obj[0] = args;
23000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23001 if (!SWIG_IsOK(res1)) {
23002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23003 }
23004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23005 result = (unsigned int) ((arg1)->m_rawFlags);
23006 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23007 return resultobj;
23008 fail:
23009 return NULL;
23010 }
23011
23012
23013 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23014 PyObject *obj;
23015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23016 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23017 return SWIG_Py_Void();
23018 }
23019
23020 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23021 return SWIG_Python_InitShadowInstance(args);
23022 }
23023
23024 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23025 PyObject *resultobj = 0;
23026 wxSize const &arg1_defvalue = wxDefaultSize ;
23027 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23028 int arg2 = (int) 0 ;
23029 wxSizeEvent *result = 0 ;
23030 wxSize temp1 ;
23031 int val2 ;
23032 int ecode2 = 0 ;
23033 PyObject * obj0 = 0 ;
23034 PyObject * obj1 = 0 ;
23035 char * kwnames[] = {
23036 (char *) "sz",(char *) "winid", NULL
23037 };
23038
23039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23040 if (obj0) {
23041 {
23042 arg1 = &temp1;
23043 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23044 }
23045 }
23046 if (obj1) {
23047 ecode2 = SWIG_AsVal_int(obj1, &val2);
23048 if (!SWIG_IsOK(ecode2)) {
23049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23050 }
23051 arg2 = static_cast< int >(val2);
23052 }
23053 {
23054 PyThreadState* __tstate = wxPyBeginAllowThreads();
23055 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23056 wxPyEndAllowThreads(__tstate);
23057 if (PyErr_Occurred()) SWIG_fail;
23058 }
23059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23060 return resultobj;
23061 fail:
23062 return NULL;
23063 }
23064
23065
23066 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23067 PyObject *resultobj = 0;
23068 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23069 wxSize result;
23070 void *argp1 = 0 ;
23071 int res1 = 0 ;
23072 PyObject *swig_obj[1] ;
23073
23074 if (!args) SWIG_fail;
23075 swig_obj[0] = args;
23076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23077 if (!SWIG_IsOK(res1)) {
23078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23079 }
23080 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 result = ((wxSizeEvent const *)arg1)->GetSize();
23084 wxPyEndAllowThreads(__tstate);
23085 if (PyErr_Occurred()) SWIG_fail;
23086 }
23087 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 PyObject *resultobj = 0;
23096 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23097 wxRect result;
23098 void *argp1 = 0 ;
23099 int res1 = 0 ;
23100 PyObject *swig_obj[1] ;
23101
23102 if (!args) SWIG_fail;
23103 swig_obj[0] = args;
23104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23107 }
23108 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23109 {
23110 PyThreadState* __tstate = wxPyBeginAllowThreads();
23111 result = ((wxSizeEvent const *)arg1)->GetRect();
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj = 0;
23124 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23125 wxRect arg2 ;
23126 void *argp1 = 0 ;
23127 int res1 = 0 ;
23128 void *argp2 ;
23129 int res2 = 0 ;
23130 PyObject * obj0 = 0 ;
23131 PyObject * obj1 = 0 ;
23132 char * kwnames[] = {
23133 (char *) "self",(char *) "rect", NULL
23134 };
23135
23136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23138 if (!SWIG_IsOK(res1)) {
23139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23140 }
23141 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23142 {
23143 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23144 if (!SWIG_IsOK(res2)) {
23145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23146 }
23147 if (!argp2) {
23148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23149 } else {
23150 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23151 arg2 = *temp;
23152 if (SWIG_IsNewObj(res2)) delete temp;
23153 }
23154 }
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 (arg1)->SetRect(arg2);
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 resultobj = SWIG_Py_Void();
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23169 PyObject *resultobj = 0;
23170 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23171 wxSize arg2 ;
23172 void *argp1 = 0 ;
23173 int res1 = 0 ;
23174 void *argp2 ;
23175 int res2 = 0 ;
23176 PyObject * obj0 = 0 ;
23177 PyObject * obj1 = 0 ;
23178 char * kwnames[] = {
23179 (char *) "self",(char *) "size", NULL
23180 };
23181
23182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23184 if (!SWIG_IsOK(res1)) {
23185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23186 }
23187 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23188 {
23189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23190 if (!SWIG_IsOK(res2)) {
23191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23192 }
23193 if (!argp2) {
23194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23195 } else {
23196 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23197 arg2 = *temp;
23198 if (SWIG_IsNewObj(res2)) delete temp;
23199 }
23200 }
23201 {
23202 PyThreadState* __tstate = wxPyBeginAllowThreads();
23203 wxSizeEvent_SetSize(arg1,arg2);
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_Py_Void();
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23215 PyObject *resultobj = 0;
23216 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23217 wxSize *arg2 = (wxSize *) 0 ;
23218 void *argp1 = 0 ;
23219 int res1 = 0 ;
23220 void *argp2 = 0 ;
23221 int res2 = 0 ;
23222 PyObject *swig_obj[2] ;
23223
23224 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23226 if (!SWIG_IsOK(res1)) {
23227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23228 }
23229 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23230 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23231 if (!SWIG_IsOK(res2)) {
23232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23233 }
23234 arg2 = reinterpret_cast< wxSize * >(argp2);
23235 if (arg1) (arg1)->m_size = *arg2;
23236
23237 resultobj = SWIG_Py_Void();
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23245 PyObject *resultobj = 0;
23246 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23247 wxSize *result = 0 ;
23248 void *argp1 = 0 ;
23249 int res1 = 0 ;
23250 PyObject *swig_obj[1] ;
23251
23252 if (!args) SWIG_fail;
23253 swig_obj[0] = args;
23254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23255 if (!SWIG_IsOK(res1)) {
23256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23257 }
23258 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23259 result = (wxSize *)& ((arg1)->m_size);
23260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 PyObject *resultobj = 0;
23269 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23270 wxRect *arg2 = (wxRect *) 0 ;
23271 void *argp1 = 0 ;
23272 int res1 = 0 ;
23273 void *argp2 = 0 ;
23274 int res2 = 0 ;
23275 PyObject *swig_obj[2] ;
23276
23277 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23279 if (!SWIG_IsOK(res1)) {
23280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23281 }
23282 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23283 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23284 if (!SWIG_IsOK(res2)) {
23285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23286 }
23287 arg2 = reinterpret_cast< wxRect * >(argp2);
23288 if (arg1) (arg1)->m_rect = *arg2;
23289
23290 resultobj = SWIG_Py_Void();
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23298 PyObject *resultobj = 0;
23299 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23300 wxRect *result = 0 ;
23301 void *argp1 = 0 ;
23302 int res1 = 0 ;
23303 PyObject *swig_obj[1] ;
23304
23305 if (!args) SWIG_fail;
23306 swig_obj[0] = args;
23307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23308 if (!SWIG_IsOK(res1)) {
23309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23310 }
23311 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23312 result = (wxRect *)& ((arg1)->m_rect);
23313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23314 return resultobj;
23315 fail:
23316 return NULL;
23317 }
23318
23319
23320 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23321 PyObject *obj;
23322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23323 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23324 return SWIG_Py_Void();
23325 }
23326
23327 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23328 return SWIG_Python_InitShadowInstance(args);
23329 }
23330
23331 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj = 0;
23333 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23334 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23335 int arg2 = (int) 0 ;
23336 wxMoveEvent *result = 0 ;
23337 wxPoint temp1 ;
23338 int val2 ;
23339 int ecode2 = 0 ;
23340 PyObject * obj0 = 0 ;
23341 PyObject * obj1 = 0 ;
23342 char * kwnames[] = {
23343 (char *) "pos",(char *) "winid", NULL
23344 };
23345
23346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23347 if (obj0) {
23348 {
23349 arg1 = &temp1;
23350 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23351 }
23352 }
23353 if (obj1) {
23354 ecode2 = SWIG_AsVal_int(obj1, &val2);
23355 if (!SWIG_IsOK(ecode2)) {
23356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23357 }
23358 arg2 = static_cast< int >(val2);
23359 }
23360 {
23361 PyThreadState* __tstate = wxPyBeginAllowThreads();
23362 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23374 PyObject *resultobj = 0;
23375 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23376 wxPoint result;
23377 void *argp1 = 0 ;
23378 int res1 = 0 ;
23379 PyObject *swig_obj[1] ;
23380
23381 if (!args) SWIG_fail;
23382 swig_obj[0] = args;
23383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23384 if (!SWIG_IsOK(res1)) {
23385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23386 }
23387 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 result = ((wxMoveEvent const *)arg1)->GetPosition();
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23402 PyObject *resultobj = 0;
23403 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23404 wxRect result;
23405 void *argp1 = 0 ;
23406 int res1 = 0 ;
23407 PyObject *swig_obj[1] ;
23408
23409 if (!args) SWIG_fail;
23410 swig_obj[0] = args;
23411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23412 if (!SWIG_IsOK(res1)) {
23413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23414 }
23415 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23416 {
23417 PyThreadState* __tstate = wxPyBeginAllowThreads();
23418 result = ((wxMoveEvent const *)arg1)->GetRect();
23419 wxPyEndAllowThreads(__tstate);
23420 if (PyErr_Occurred()) SWIG_fail;
23421 }
23422 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23423 return resultobj;
23424 fail:
23425 return NULL;
23426 }
23427
23428
23429 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23430 PyObject *resultobj = 0;
23431 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23432 wxRect *arg2 = 0 ;
23433 void *argp1 = 0 ;
23434 int res1 = 0 ;
23435 wxRect temp2 ;
23436 PyObject * obj0 = 0 ;
23437 PyObject * obj1 = 0 ;
23438 char * kwnames[] = {
23439 (char *) "self",(char *) "rect", NULL
23440 };
23441
23442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23444 if (!SWIG_IsOK(res1)) {
23445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23446 }
23447 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23448 {
23449 arg2 = &temp2;
23450 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23451 }
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 (arg1)->SetRect((wxRect const &)*arg2);
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 resultobj = SWIG_Py_Void();
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23466 PyObject *resultobj = 0;
23467 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23468 wxPoint *arg2 = 0 ;
23469 void *argp1 = 0 ;
23470 int res1 = 0 ;
23471 wxPoint temp2 ;
23472 PyObject * obj0 = 0 ;
23473 PyObject * obj1 = 0 ;
23474 char * kwnames[] = {
23475 (char *) "self",(char *) "pos", NULL
23476 };
23477
23478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23480 if (!SWIG_IsOK(res1)) {
23481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23482 }
23483 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23484 {
23485 arg2 = &temp2;
23486 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23487 }
23488 {
23489 PyThreadState* __tstate = wxPyBeginAllowThreads();
23490 (arg1)->SetPosition((wxPoint const &)*arg2);
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 resultobj = SWIG_Py_Void();
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 PyObject *obj;
23503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23504 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23505 return SWIG_Py_Void();
23506 }
23507
23508 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23509 return SWIG_Python_InitShadowInstance(args);
23510 }
23511
23512 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23513 PyObject *resultobj = 0;
23514 int arg1 = (int) 0 ;
23515 wxPaintEvent *result = 0 ;
23516 int val1 ;
23517 int ecode1 = 0 ;
23518 PyObject * obj0 = 0 ;
23519 char * kwnames[] = {
23520 (char *) "Id", NULL
23521 };
23522
23523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23524 if (obj0) {
23525 ecode1 = SWIG_AsVal_int(obj0, &val1);
23526 if (!SWIG_IsOK(ecode1)) {
23527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23528 }
23529 arg1 = static_cast< int >(val1);
23530 }
23531 {
23532 PyThreadState* __tstate = wxPyBeginAllowThreads();
23533 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23534 wxPyEndAllowThreads(__tstate);
23535 if (PyErr_Occurred()) SWIG_fail;
23536 }
23537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23545 PyObject *obj;
23546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23547 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23548 return SWIG_Py_Void();
23549 }
23550
23551 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23552 return SWIG_Python_InitShadowInstance(args);
23553 }
23554
23555 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23556 PyObject *resultobj = 0;
23557 int arg1 = (int) 0 ;
23558 wxNcPaintEvent *result = 0 ;
23559 int val1 ;
23560 int ecode1 = 0 ;
23561 PyObject * obj0 = 0 ;
23562 char * kwnames[] = {
23563 (char *) "winid", NULL
23564 };
23565
23566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23567 if (obj0) {
23568 ecode1 = SWIG_AsVal_int(obj0, &val1);
23569 if (!SWIG_IsOK(ecode1)) {
23570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23571 }
23572 arg1 = static_cast< int >(val1);
23573 }
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23588 PyObject *obj;
23589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23590 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23591 return SWIG_Py_Void();
23592 }
23593
23594 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23595 return SWIG_Python_InitShadowInstance(args);
23596 }
23597
23598 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23599 PyObject *resultobj = 0;
23600 int arg1 = (int) 0 ;
23601 wxDC *arg2 = (wxDC *) NULL ;
23602 wxEraseEvent *result = 0 ;
23603 int val1 ;
23604 int ecode1 = 0 ;
23605 void *argp2 = 0 ;
23606 int res2 = 0 ;
23607 PyObject * obj0 = 0 ;
23608 PyObject * obj1 = 0 ;
23609 char * kwnames[] = {
23610 (char *) "Id",(char *) "dc", NULL
23611 };
23612
23613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23614 if (obj0) {
23615 ecode1 = SWIG_AsVal_int(obj0, &val1);
23616 if (!SWIG_IsOK(ecode1)) {
23617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23618 }
23619 arg1 = static_cast< int >(val1);
23620 }
23621 if (obj1) {
23622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23623 if (!SWIG_IsOK(res2)) {
23624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23625 }
23626 arg2 = reinterpret_cast< wxDC * >(argp2);
23627 }
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23642 PyObject *resultobj = 0;
23643 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23644 wxDC *result = 0 ;
23645 void *argp1 = 0 ;
23646 int res1 = 0 ;
23647 PyObject *swig_obj[1] ;
23648
23649 if (!args) SWIG_fail;
23650 swig_obj[0] = args;
23651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23652 if (!SWIG_IsOK(res1)) {
23653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23654 }
23655 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23656 {
23657 PyThreadState* __tstate = wxPyBeginAllowThreads();
23658 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 {
23663 resultobj = wxPyMake_wxObject(result, (bool)0);
23664 }
23665 return resultobj;
23666 fail:
23667 return NULL;
23668 }
23669
23670
23671 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23672 PyObject *obj;
23673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23674 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23675 return SWIG_Py_Void();
23676 }
23677
23678 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23679 return SWIG_Python_InitShadowInstance(args);
23680 }
23681
23682 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23683 PyObject *resultobj = 0;
23684 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23685 int arg2 = (int) 0 ;
23686 wxFocusEvent *result = 0 ;
23687 int val1 ;
23688 int ecode1 = 0 ;
23689 int val2 ;
23690 int ecode2 = 0 ;
23691 PyObject * obj0 = 0 ;
23692 PyObject * obj1 = 0 ;
23693 char * kwnames[] = {
23694 (char *) "type",(char *) "winid", NULL
23695 };
23696
23697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23698 if (obj0) {
23699 ecode1 = SWIG_AsVal_int(obj0, &val1);
23700 if (!SWIG_IsOK(ecode1)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23702 }
23703 arg1 = static_cast< wxEventType >(val1);
23704 }
23705 if (obj1) {
23706 ecode2 = SWIG_AsVal_int(obj1, &val2);
23707 if (!SWIG_IsOK(ecode2)) {
23708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23709 }
23710 arg2 = static_cast< int >(val2);
23711 }
23712 {
23713 PyThreadState* __tstate = wxPyBeginAllowThreads();
23714 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23726 PyObject *resultobj = 0;
23727 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23728 wxWindow *result = 0 ;
23729 void *argp1 = 0 ;
23730 int res1 = 0 ;
23731 PyObject *swig_obj[1] ;
23732
23733 if (!args) SWIG_fail;
23734 swig_obj[0] = args;
23735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23736 if (!SWIG_IsOK(res1)) {
23737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23738 }
23739 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23740 {
23741 PyThreadState* __tstate = wxPyBeginAllowThreads();
23742 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 {
23747 resultobj = wxPyMake_wxObject(result, (bool)0);
23748 }
23749 return resultobj;
23750 fail:
23751 return NULL;
23752 }
23753
23754
23755 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23756 PyObject *resultobj = 0;
23757 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23758 wxWindow *arg2 = (wxWindow *) 0 ;
23759 void *argp1 = 0 ;
23760 int res1 = 0 ;
23761 void *argp2 = 0 ;
23762 int res2 = 0 ;
23763 PyObject * obj0 = 0 ;
23764 PyObject * obj1 = 0 ;
23765 char * kwnames[] = {
23766 (char *) "self",(char *) "win", NULL
23767 };
23768
23769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23771 if (!SWIG_IsOK(res1)) {
23772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23773 }
23774 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23776 if (!SWIG_IsOK(res2)) {
23777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23778 }
23779 arg2 = reinterpret_cast< wxWindow * >(argp2);
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 (arg1)->SetWindow(arg2);
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 resultobj = SWIG_Py_Void();
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23794 PyObject *obj;
23795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23796 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23797 return SWIG_Py_Void();
23798 }
23799
23800 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23801 return SWIG_Python_InitShadowInstance(args);
23802 }
23803
23804 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj = 0;
23806 wxWindow *arg1 = (wxWindow *) NULL ;
23807 wxChildFocusEvent *result = 0 ;
23808 void *argp1 = 0 ;
23809 int res1 = 0 ;
23810 PyObject * obj0 = 0 ;
23811 char * kwnames[] = {
23812 (char *) "win", NULL
23813 };
23814
23815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23816 if (obj0) {
23817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23818 if (!SWIG_IsOK(res1)) {
23819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23820 }
23821 arg1 = reinterpret_cast< wxWindow * >(argp1);
23822 }
23823 {
23824 PyThreadState* __tstate = wxPyBeginAllowThreads();
23825 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23826 wxPyEndAllowThreads(__tstate);
23827 if (PyErr_Occurred()) SWIG_fail;
23828 }
23829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23837 PyObject *resultobj = 0;
23838 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23839 wxWindow *result = 0 ;
23840 void *argp1 = 0 ;
23841 int res1 = 0 ;
23842 PyObject *swig_obj[1] ;
23843
23844 if (!args) SWIG_fail;
23845 swig_obj[0] = args;
23846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23847 if (!SWIG_IsOK(res1)) {
23848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23849 }
23850 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 {
23858 resultobj = wxPyMake_wxObject(result, (bool)0);
23859 }
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23867 PyObject *obj;
23868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23869 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23870 return SWIG_Py_Void();
23871 }
23872
23873 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23874 return SWIG_Python_InitShadowInstance(args);
23875 }
23876
23877 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23878 PyObject *resultobj = 0;
23879 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23880 bool arg2 = (bool) true ;
23881 int arg3 = (int) 0 ;
23882 wxActivateEvent *result = 0 ;
23883 int val1 ;
23884 int ecode1 = 0 ;
23885 bool val2 ;
23886 int ecode2 = 0 ;
23887 int val3 ;
23888 int ecode3 = 0 ;
23889 PyObject * obj0 = 0 ;
23890 PyObject * obj1 = 0 ;
23891 PyObject * obj2 = 0 ;
23892 char * kwnames[] = {
23893 (char *) "type",(char *) "active",(char *) "Id", NULL
23894 };
23895
23896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23897 if (obj0) {
23898 ecode1 = SWIG_AsVal_int(obj0, &val1);
23899 if (!SWIG_IsOK(ecode1)) {
23900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23901 }
23902 arg1 = static_cast< wxEventType >(val1);
23903 }
23904 if (obj1) {
23905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23906 if (!SWIG_IsOK(ecode2)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23908 }
23909 arg2 = static_cast< bool >(val2);
23910 }
23911 if (obj2) {
23912 ecode3 = SWIG_AsVal_int(obj2, &val3);
23913 if (!SWIG_IsOK(ecode3)) {
23914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23915 }
23916 arg3 = static_cast< int >(val3);
23917 }
23918 {
23919 PyThreadState* __tstate = wxPyBeginAllowThreads();
23920 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23921 wxPyEndAllowThreads(__tstate);
23922 if (PyErr_Occurred()) SWIG_fail;
23923 }
23924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23932 PyObject *resultobj = 0;
23933 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23934 bool result;
23935 void *argp1 = 0 ;
23936 int res1 = 0 ;
23937 PyObject *swig_obj[1] ;
23938
23939 if (!args) SWIG_fail;
23940 swig_obj[0] = args;
23941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23942 if (!SWIG_IsOK(res1)) {
23943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23944 }
23945 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 {
23953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23954 }
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23962 PyObject *obj;
23963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23964 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23965 return SWIG_Py_Void();
23966 }
23967
23968 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23969 return SWIG_Python_InitShadowInstance(args);
23970 }
23971
23972 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23973 PyObject *resultobj = 0;
23974 int arg1 = (int) 0 ;
23975 wxInitDialogEvent *result = 0 ;
23976 int val1 ;
23977 int ecode1 = 0 ;
23978 PyObject * obj0 = 0 ;
23979 char * kwnames[] = {
23980 (char *) "Id", NULL
23981 };
23982
23983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23984 if (obj0) {
23985 ecode1 = SWIG_AsVal_int(obj0, &val1);
23986 if (!SWIG_IsOK(ecode1)) {
23987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23988 }
23989 arg1 = static_cast< int >(val1);
23990 }
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *obj;
24006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24007 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24008 return SWIG_Py_Void();
24009 }
24010
24011 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24012 return SWIG_Python_InitShadowInstance(args);
24013 }
24014
24015 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24016 PyObject *resultobj = 0;
24017 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24018 int arg2 = (int) 0 ;
24019 wxMenu *arg3 = (wxMenu *) NULL ;
24020 wxMenuEvent *result = 0 ;
24021 int val1 ;
24022 int ecode1 = 0 ;
24023 int val2 ;
24024 int ecode2 = 0 ;
24025 void *argp3 = 0 ;
24026 int res3 = 0 ;
24027 PyObject * obj0 = 0 ;
24028 PyObject * obj1 = 0 ;
24029 PyObject * obj2 = 0 ;
24030 char * kwnames[] = {
24031 (char *) "type",(char *) "winid",(char *) "menu", NULL
24032 };
24033
24034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24035 if (obj0) {
24036 ecode1 = SWIG_AsVal_int(obj0, &val1);
24037 if (!SWIG_IsOK(ecode1)) {
24038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24039 }
24040 arg1 = static_cast< wxEventType >(val1);
24041 }
24042 if (obj1) {
24043 ecode2 = SWIG_AsVal_int(obj1, &val2);
24044 if (!SWIG_IsOK(ecode2)) {
24045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24046 }
24047 arg2 = static_cast< int >(val2);
24048 }
24049 if (obj2) {
24050 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24051 if (!SWIG_IsOK(res3)) {
24052 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24053 }
24054 arg3 = reinterpret_cast< wxMenu * >(argp3);
24055 }
24056 {
24057 PyThreadState* __tstate = wxPyBeginAllowThreads();
24058 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24059 wxPyEndAllowThreads(__tstate);
24060 if (PyErr_Occurred()) SWIG_fail;
24061 }
24062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24063 return resultobj;
24064 fail:
24065 return NULL;
24066 }
24067
24068
24069 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24070 PyObject *resultobj = 0;
24071 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24072 int result;
24073 void *argp1 = 0 ;
24074 int res1 = 0 ;
24075 PyObject *swig_obj[1] ;
24076
24077 if (!args) SWIG_fail;
24078 swig_obj[0] = args;
24079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24080 if (!SWIG_IsOK(res1)) {
24081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24082 }
24083 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24084 {
24085 PyThreadState* __tstate = wxPyBeginAllowThreads();
24086 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 resultobj = SWIG_From_int(static_cast< int >(result));
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24098 PyObject *resultobj = 0;
24099 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24100 bool result;
24101 void *argp1 = 0 ;
24102 int res1 = 0 ;
24103 PyObject *swig_obj[1] ;
24104
24105 if (!args) SWIG_fail;
24106 swig_obj[0] = args;
24107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24108 if (!SWIG_IsOK(res1)) {
24109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24110 }
24111 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24112 {
24113 PyThreadState* __tstate = wxPyBeginAllowThreads();
24114 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 {
24119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24120 }
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24128 PyObject *resultobj = 0;
24129 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24130 wxMenu *result = 0 ;
24131 void *argp1 = 0 ;
24132 int res1 = 0 ;
24133 PyObject *swig_obj[1] ;
24134
24135 if (!args) SWIG_fail;
24136 swig_obj[0] = args;
24137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24138 if (!SWIG_IsOK(res1)) {
24139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24140 }
24141 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24142 {
24143 PyThreadState* __tstate = wxPyBeginAllowThreads();
24144 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 {
24149 resultobj = wxPyMake_wxObject(result, (bool)0);
24150 }
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 PyObject *obj;
24159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24160 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24161 return SWIG_Py_Void();
24162 }
24163
24164 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24165 return SWIG_Python_InitShadowInstance(args);
24166 }
24167
24168 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24169 PyObject *resultobj = 0;
24170 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24171 int arg2 = (int) 0 ;
24172 wxCloseEvent *result = 0 ;
24173 int val1 ;
24174 int ecode1 = 0 ;
24175 int val2 ;
24176 int ecode2 = 0 ;
24177 PyObject * obj0 = 0 ;
24178 PyObject * obj1 = 0 ;
24179 char * kwnames[] = {
24180 (char *) "type",(char *) "winid", NULL
24181 };
24182
24183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24184 if (obj0) {
24185 ecode1 = SWIG_AsVal_int(obj0, &val1);
24186 if (!SWIG_IsOK(ecode1)) {
24187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24188 }
24189 arg1 = static_cast< wxEventType >(val1);
24190 }
24191 if (obj1) {
24192 ecode2 = SWIG_AsVal_int(obj1, &val2);
24193 if (!SWIG_IsOK(ecode2)) {
24194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24195 }
24196 arg2 = static_cast< int >(val2);
24197 }
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj = 0;
24213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24214 bool arg2 ;
24215 void *argp1 = 0 ;
24216 int res1 = 0 ;
24217 bool val2 ;
24218 int ecode2 = 0 ;
24219 PyObject * obj0 = 0 ;
24220 PyObject * obj1 = 0 ;
24221 char * kwnames[] = {
24222 (char *) "self",(char *) "logOff", NULL
24223 };
24224
24225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24229 }
24230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24232 if (!SWIG_IsOK(ecode2)) {
24233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24234 }
24235 arg2 = static_cast< bool >(val2);
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 (arg1)->SetLoggingOff(arg2);
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 resultobj = SWIG_Py_Void();
24243 return resultobj;
24244 fail:
24245 return NULL;
24246 }
24247
24248
24249 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 PyObject *resultobj = 0;
24251 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24252 bool result;
24253 void *argp1 = 0 ;
24254 int res1 = 0 ;
24255 PyObject *swig_obj[1] ;
24256
24257 if (!args) SWIG_fail;
24258 swig_obj[0] = args;
24259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24260 if (!SWIG_IsOK(res1)) {
24261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24262 }
24263 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 {
24271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24272 }
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24280 PyObject *resultobj = 0;
24281 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24282 bool arg2 = (bool) true ;
24283 void *argp1 = 0 ;
24284 int res1 = 0 ;
24285 bool val2 ;
24286 int ecode2 = 0 ;
24287 PyObject * obj0 = 0 ;
24288 PyObject * obj1 = 0 ;
24289 char * kwnames[] = {
24290 (char *) "self",(char *) "veto", NULL
24291 };
24292
24293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24295 if (!SWIG_IsOK(res1)) {
24296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24297 }
24298 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24299 if (obj1) {
24300 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24301 if (!SWIG_IsOK(ecode2)) {
24302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24303 }
24304 arg2 = static_cast< bool >(val2);
24305 }
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 (arg1)->Veto(arg2);
24309 wxPyEndAllowThreads(__tstate);
24310 if (PyErr_Occurred()) SWIG_fail;
24311 }
24312 resultobj = SWIG_Py_Void();
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 PyObject *resultobj = 0;
24321 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24322 bool result;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 PyObject *swig_obj[1] ;
24326
24327 if (!args) SWIG_fail;
24328 swig_obj[0] = args;
24329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24330 if (!SWIG_IsOK(res1)) {
24331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24332 }
24333 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24337 wxPyEndAllowThreads(__tstate);
24338 if (PyErr_Occurred()) SWIG_fail;
24339 }
24340 {
24341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24342 }
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24350 PyObject *resultobj = 0;
24351 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24352 bool arg2 ;
24353 void *argp1 = 0 ;
24354 int res1 = 0 ;
24355 bool val2 ;
24356 int ecode2 = 0 ;
24357 PyObject * obj0 = 0 ;
24358 PyObject * obj1 = 0 ;
24359 char * kwnames[] = {
24360 (char *) "self",(char *) "canVeto", NULL
24361 };
24362
24363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24365 if (!SWIG_IsOK(res1)) {
24366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24367 }
24368 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24370 if (!SWIG_IsOK(ecode2)) {
24371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24372 }
24373 arg2 = static_cast< bool >(val2);
24374 {
24375 PyThreadState* __tstate = wxPyBeginAllowThreads();
24376 (arg1)->SetCanVeto(arg2);
24377 wxPyEndAllowThreads(__tstate);
24378 if (PyErr_Occurred()) SWIG_fail;
24379 }
24380 resultobj = SWIG_Py_Void();
24381 return resultobj;
24382 fail:
24383 return NULL;
24384 }
24385
24386
24387 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24388 PyObject *resultobj = 0;
24389 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24390 bool result;
24391 void *argp1 = 0 ;
24392 int res1 = 0 ;
24393 PyObject *swig_obj[1] ;
24394
24395 if (!args) SWIG_fail;
24396 swig_obj[0] = args;
24397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24398 if (!SWIG_IsOK(res1)) {
24399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24400 }
24401 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24402 {
24403 PyThreadState* __tstate = wxPyBeginAllowThreads();
24404 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24405 wxPyEndAllowThreads(__tstate);
24406 if (PyErr_Occurred()) SWIG_fail;
24407 }
24408 {
24409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24410 }
24411 return resultobj;
24412 fail:
24413 return NULL;
24414 }
24415
24416
24417 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24418 PyObject *obj;
24419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24420 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24421 return SWIG_Py_Void();
24422 }
24423
24424 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24425 return SWIG_Python_InitShadowInstance(args);
24426 }
24427
24428 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24429 PyObject *resultobj = 0;
24430 int arg1 = (int) 0 ;
24431 bool arg2 = (bool) false ;
24432 wxShowEvent *result = 0 ;
24433 int val1 ;
24434 int ecode1 = 0 ;
24435 bool val2 ;
24436 int ecode2 = 0 ;
24437 PyObject * obj0 = 0 ;
24438 PyObject * obj1 = 0 ;
24439 char * kwnames[] = {
24440 (char *) "winid",(char *) "show", NULL
24441 };
24442
24443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24444 if (obj0) {
24445 ecode1 = SWIG_AsVal_int(obj0, &val1);
24446 if (!SWIG_IsOK(ecode1)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24448 }
24449 arg1 = static_cast< int >(val1);
24450 }
24451 if (obj1) {
24452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24453 if (!SWIG_IsOK(ecode2)) {
24454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24455 }
24456 arg2 = static_cast< bool >(val2);
24457 }
24458 {
24459 PyThreadState* __tstate = wxPyBeginAllowThreads();
24460 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24461 wxPyEndAllowThreads(__tstate);
24462 if (PyErr_Occurred()) SWIG_fail;
24463 }
24464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24472 PyObject *resultobj = 0;
24473 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24474 bool arg2 ;
24475 void *argp1 = 0 ;
24476 int res1 = 0 ;
24477 bool val2 ;
24478 int ecode2 = 0 ;
24479 PyObject * obj0 = 0 ;
24480 PyObject * obj1 = 0 ;
24481 char * kwnames[] = {
24482 (char *) "self",(char *) "show", NULL
24483 };
24484
24485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24487 if (!SWIG_IsOK(res1)) {
24488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24489 }
24490 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24492 if (!SWIG_IsOK(ecode2)) {
24493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24494 }
24495 arg2 = static_cast< bool >(val2);
24496 {
24497 PyThreadState* __tstate = wxPyBeginAllowThreads();
24498 (arg1)->SetShow(arg2);
24499 wxPyEndAllowThreads(__tstate);
24500 if (PyErr_Occurred()) SWIG_fail;
24501 }
24502 resultobj = SWIG_Py_Void();
24503 return resultobj;
24504 fail:
24505 return NULL;
24506 }
24507
24508
24509 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24510 PyObject *resultobj = 0;
24511 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24512 bool result;
24513 void *argp1 = 0 ;
24514 int res1 = 0 ;
24515 PyObject *swig_obj[1] ;
24516
24517 if (!args) SWIG_fail;
24518 swig_obj[0] = args;
24519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24520 if (!SWIG_IsOK(res1)) {
24521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24522 }
24523 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24527 wxPyEndAllowThreads(__tstate);
24528 if (PyErr_Occurred()) SWIG_fail;
24529 }
24530 {
24531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24532 }
24533 return resultobj;
24534 fail:
24535 return NULL;
24536 }
24537
24538
24539 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24540 PyObject *obj;
24541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24542 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24543 return SWIG_Py_Void();
24544 }
24545
24546 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24547 return SWIG_Python_InitShadowInstance(args);
24548 }
24549
24550 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24551 PyObject *resultobj = 0;
24552 int arg1 = (int) 0 ;
24553 bool arg2 = (bool) true ;
24554 wxIconizeEvent *result = 0 ;
24555 int val1 ;
24556 int ecode1 = 0 ;
24557 bool val2 ;
24558 int ecode2 = 0 ;
24559 PyObject * obj0 = 0 ;
24560 PyObject * obj1 = 0 ;
24561 char * kwnames[] = {
24562 (char *) "id",(char *) "iconized", NULL
24563 };
24564
24565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24566 if (obj0) {
24567 ecode1 = SWIG_AsVal_int(obj0, &val1);
24568 if (!SWIG_IsOK(ecode1)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24570 }
24571 arg1 = static_cast< int >(val1);
24572 }
24573 if (obj1) {
24574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24575 if (!SWIG_IsOK(ecode2)) {
24576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24577 }
24578 arg2 = static_cast< bool >(val2);
24579 }
24580 {
24581 PyThreadState* __tstate = wxPyBeginAllowThreads();
24582 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24587 return resultobj;
24588 fail:
24589 return NULL;
24590 }
24591
24592
24593 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24594 PyObject *resultobj = 0;
24595 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24596 bool result;
24597 void *argp1 = 0 ;
24598 int res1 = 0 ;
24599 PyObject *swig_obj[1] ;
24600
24601 if (!args) SWIG_fail;
24602 swig_obj[0] = args;
24603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24604 if (!SWIG_IsOK(res1)) {
24605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24606 }
24607 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24608 {
24609 PyThreadState* __tstate = wxPyBeginAllowThreads();
24610 result = (bool)(arg1)->Iconized();
24611 wxPyEndAllowThreads(__tstate);
24612 if (PyErr_Occurred()) SWIG_fail;
24613 }
24614 {
24615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24616 }
24617 return resultobj;
24618 fail:
24619 return NULL;
24620 }
24621
24622
24623 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24624 PyObject *obj;
24625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24626 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24627 return SWIG_Py_Void();
24628 }
24629
24630 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 return SWIG_Python_InitShadowInstance(args);
24632 }
24633
24634 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj = 0;
24636 int arg1 = (int) 0 ;
24637 wxMaximizeEvent *result = 0 ;
24638 int val1 ;
24639 int ecode1 = 0 ;
24640 PyObject * obj0 = 0 ;
24641 char * kwnames[] = {
24642 (char *) "id", NULL
24643 };
24644
24645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24646 if (obj0) {
24647 ecode1 = SWIG_AsVal_int(obj0, &val1);
24648 if (!SWIG_IsOK(ecode1)) {
24649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24650 }
24651 arg1 = static_cast< int >(val1);
24652 }
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24656 wxPyEndAllowThreads(__tstate);
24657 if (PyErr_Occurred()) SWIG_fail;
24658 }
24659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24660 return resultobj;
24661 fail:
24662 return NULL;
24663 }
24664
24665
24666 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24667 PyObject *obj;
24668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24669 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24670 return SWIG_Py_Void();
24671 }
24672
24673 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24674 return SWIG_Python_InitShadowInstance(args);
24675 }
24676
24677 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24678 PyObject *resultobj = 0;
24679 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24680 wxPoint result;
24681 void *argp1 = 0 ;
24682 int res1 = 0 ;
24683 PyObject *swig_obj[1] ;
24684
24685 if (!args) SWIG_fail;
24686 swig_obj[0] = args;
24687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24688 if (!SWIG_IsOK(res1)) {
24689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24690 }
24691 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 result = (arg1)->GetPosition();
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24706 PyObject *resultobj = 0;
24707 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24708 int result;
24709 void *argp1 = 0 ;
24710 int res1 = 0 ;
24711 PyObject *swig_obj[1] ;
24712
24713 if (!args) SWIG_fail;
24714 swig_obj[0] = args;
24715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24716 if (!SWIG_IsOK(res1)) {
24717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24718 }
24719 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 result = (int)(arg1)->GetNumberOfFiles();
24723 wxPyEndAllowThreads(__tstate);
24724 if (PyErr_Occurred()) SWIG_fail;
24725 }
24726 resultobj = SWIG_From_int(static_cast< int >(result));
24727 return resultobj;
24728 fail:
24729 return NULL;
24730 }
24731
24732
24733 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24734 PyObject *resultobj = 0;
24735 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24736 PyObject *result = 0 ;
24737 void *argp1 = 0 ;
24738 int res1 = 0 ;
24739 PyObject *swig_obj[1] ;
24740
24741 if (!args) SWIG_fail;
24742 swig_obj[0] = args;
24743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24744 if (!SWIG_IsOK(res1)) {
24745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24746 }
24747 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24751 wxPyEndAllowThreads(__tstate);
24752 if (PyErr_Occurred()) SWIG_fail;
24753 }
24754 resultobj = result;
24755 return resultobj;
24756 fail:
24757 return NULL;
24758 }
24759
24760
24761 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24762 PyObject *obj;
24763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24764 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24765 return SWIG_Py_Void();
24766 }
24767
24768 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24769 PyObject *resultobj = 0;
24770 int arg1 = (int) 0 ;
24771 wxUpdateUIEvent *result = 0 ;
24772 int val1 ;
24773 int ecode1 = 0 ;
24774 PyObject * obj0 = 0 ;
24775 char * kwnames[] = {
24776 (char *) "commandId", NULL
24777 };
24778
24779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24780 if (obj0) {
24781 ecode1 = SWIG_AsVal_int(obj0, &val1);
24782 if (!SWIG_IsOK(ecode1)) {
24783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24784 }
24785 arg1 = static_cast< int >(val1);
24786 }
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24790 wxPyEndAllowThreads(__tstate);
24791 if (PyErr_Occurred()) SWIG_fail;
24792 }
24793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24794 return resultobj;
24795 fail:
24796 return NULL;
24797 }
24798
24799
24800 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24801 PyObject *resultobj = 0;
24802 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24803 bool result;
24804 void *argp1 = 0 ;
24805 int res1 = 0 ;
24806 PyObject *swig_obj[1] ;
24807
24808 if (!args) SWIG_fail;
24809 swig_obj[0] = args;
24810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24811 if (!SWIG_IsOK(res1)) {
24812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24813 }
24814 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24818 wxPyEndAllowThreads(__tstate);
24819 if (PyErr_Occurred()) SWIG_fail;
24820 }
24821 {
24822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24823 }
24824 return resultobj;
24825 fail:
24826 return NULL;
24827 }
24828
24829
24830 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24831 PyObject *resultobj = 0;
24832 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24833 bool result;
24834 void *argp1 = 0 ;
24835 int res1 = 0 ;
24836 PyObject *swig_obj[1] ;
24837
24838 if (!args) SWIG_fail;
24839 swig_obj[0] = args;
24840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24841 if (!SWIG_IsOK(res1)) {
24842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24843 }
24844 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24845 {
24846 PyThreadState* __tstate = wxPyBeginAllowThreads();
24847 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24848 wxPyEndAllowThreads(__tstate);
24849 if (PyErr_Occurred()) SWIG_fail;
24850 }
24851 {
24852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24853 }
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24861 PyObject *resultobj = 0;
24862 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24863 bool result;
24864 void *argp1 = 0 ;
24865 int res1 = 0 ;
24866 PyObject *swig_obj[1] ;
24867
24868 if (!args) SWIG_fail;
24869 swig_obj[0] = args;
24870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24871 if (!SWIG_IsOK(res1)) {
24872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24873 }
24874 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24875 {
24876 PyThreadState* __tstate = wxPyBeginAllowThreads();
24877 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24878 wxPyEndAllowThreads(__tstate);
24879 if (PyErr_Occurred()) SWIG_fail;
24880 }
24881 {
24882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24883 }
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24893 wxString result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 PyObject *swig_obj[1] ;
24897
24898 if (!args) SWIG_fail;
24899 swig_obj[0] = args;
24900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24903 }
24904 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 #if wxUSE_UNICODE
24913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24914 #else
24915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24916 #endif
24917 }
24918 return resultobj;
24919 fail:
24920 return NULL;
24921 }
24922
24923
24924 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24925 PyObject *resultobj = 0;
24926 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24927 bool result;
24928 void *argp1 = 0 ;
24929 int res1 = 0 ;
24930 PyObject *swig_obj[1] ;
24931
24932 if (!args) SWIG_fail;
24933 swig_obj[0] = args;
24934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24935 if (!SWIG_IsOK(res1)) {
24936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24937 }
24938 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24939 {
24940 PyThreadState* __tstate = wxPyBeginAllowThreads();
24941 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24942 wxPyEndAllowThreads(__tstate);
24943 if (PyErr_Occurred()) SWIG_fail;
24944 }
24945 {
24946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24947 }
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24955 PyObject *resultobj = 0;
24956 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24957 bool result;
24958 void *argp1 = 0 ;
24959 int res1 = 0 ;
24960 PyObject *swig_obj[1] ;
24961
24962 if (!args) SWIG_fail;
24963 swig_obj[0] = args;
24964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24965 if (!SWIG_IsOK(res1)) {
24966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24967 }
24968 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 {
24976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24977 }
24978 return resultobj;
24979 fail:
24980 return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24985 PyObject *resultobj = 0;
24986 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24987 bool result;
24988 void *argp1 = 0 ;
24989 int res1 = 0 ;
24990 PyObject *swig_obj[1] ;
24991
24992 if (!args) SWIG_fail;
24993 swig_obj[0] = args;
24994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24995 if (!SWIG_IsOK(res1)) {
24996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24997 }
24998 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 {
25006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25007 }
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25015 PyObject *resultobj = 0;
25016 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25017 bool result;
25018 void *argp1 = 0 ;
25019 int res1 = 0 ;
25020 PyObject *swig_obj[1] ;
25021
25022 if (!args) SWIG_fail;
25023 swig_obj[0] = args;
25024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25025 if (!SWIG_IsOK(res1)) {
25026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25027 }
25028 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 {
25036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25037 }
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25045 PyObject *resultobj = 0;
25046 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25047 bool arg2 ;
25048 void *argp1 = 0 ;
25049 int res1 = 0 ;
25050 bool val2 ;
25051 int ecode2 = 0 ;
25052 PyObject * obj0 = 0 ;
25053 PyObject * obj1 = 0 ;
25054 char * kwnames[] = {
25055 (char *) "self",(char *) "check", NULL
25056 };
25057
25058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25060 if (!SWIG_IsOK(res1)) {
25061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25062 }
25063 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25064 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25065 if (!SWIG_IsOK(ecode2)) {
25066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25067 }
25068 arg2 = static_cast< bool >(val2);
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 (arg1)->Check(arg2);
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_Py_Void();
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25083 PyObject *resultobj = 0;
25084 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25085 bool arg2 ;
25086 void *argp1 = 0 ;
25087 int res1 = 0 ;
25088 bool val2 ;
25089 int ecode2 = 0 ;
25090 PyObject * obj0 = 0 ;
25091 PyObject * obj1 = 0 ;
25092 char * kwnames[] = {
25093 (char *) "self",(char *) "enable", NULL
25094 };
25095
25096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25098 if (!SWIG_IsOK(res1)) {
25099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25100 }
25101 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25103 if (!SWIG_IsOK(ecode2)) {
25104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25105 }
25106 arg2 = static_cast< bool >(val2);
25107 {
25108 PyThreadState* __tstate = wxPyBeginAllowThreads();
25109 (arg1)->Enable(arg2);
25110 wxPyEndAllowThreads(__tstate);
25111 if (PyErr_Occurred()) SWIG_fail;
25112 }
25113 resultobj = SWIG_Py_Void();
25114 return resultobj;
25115 fail:
25116 return NULL;
25117 }
25118
25119
25120 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25121 PyObject *resultobj = 0;
25122 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25123 bool arg2 ;
25124 void *argp1 = 0 ;
25125 int res1 = 0 ;
25126 bool val2 ;
25127 int ecode2 = 0 ;
25128 PyObject * obj0 = 0 ;
25129 PyObject * obj1 = 0 ;
25130 char * kwnames[] = {
25131 (char *) "self",(char *) "show", NULL
25132 };
25133
25134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25136 if (!SWIG_IsOK(res1)) {
25137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25138 }
25139 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25140 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25141 if (!SWIG_IsOK(ecode2)) {
25142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25143 }
25144 arg2 = static_cast< bool >(val2);
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 (arg1)->Show(arg2);
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 resultobj = SWIG_Py_Void();
25152 return resultobj;
25153 fail:
25154 return NULL;
25155 }
25156
25157
25158 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj = 0;
25160 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25161 wxString *arg2 = 0 ;
25162 void *argp1 = 0 ;
25163 int res1 = 0 ;
25164 bool temp2 = false ;
25165 PyObject * obj0 = 0 ;
25166 PyObject * obj1 = 0 ;
25167 char * kwnames[] = {
25168 (char *) "self",(char *) "text", NULL
25169 };
25170
25171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25173 if (!SWIG_IsOK(res1)) {
25174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25175 }
25176 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25177 {
25178 arg2 = wxString_in_helper(obj1);
25179 if (arg2 == NULL) SWIG_fail;
25180 temp2 = true;
25181 }
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 (arg1)->SetText((wxString const &)*arg2);
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 resultobj = SWIG_Py_Void();
25189 {
25190 if (temp2)
25191 delete arg2;
25192 }
25193 return resultobj;
25194 fail:
25195 {
25196 if (temp2)
25197 delete arg2;
25198 }
25199 return NULL;
25200 }
25201
25202
25203 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25204 PyObject *resultobj = 0;
25205 long arg1 ;
25206 long val1 ;
25207 int ecode1 = 0 ;
25208 PyObject * obj0 = 0 ;
25209 char * kwnames[] = {
25210 (char *) "updateInterval", NULL
25211 };
25212
25213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25214 ecode1 = SWIG_AsVal_long(obj0, &val1);
25215 if (!SWIG_IsOK(ecode1)) {
25216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25217 }
25218 arg1 = static_cast< long >(val1);
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 wxUpdateUIEvent::SetUpdateInterval(arg1);
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 resultobj = SWIG_Py_Void();
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25233 PyObject *resultobj = 0;
25234 long result;
25235
25236 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25237 {
25238 PyThreadState* __tstate = wxPyBeginAllowThreads();
25239 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 resultobj = SWIG_From_long(static_cast< long >(result));
25244 return resultobj;
25245 fail:
25246 return NULL;
25247 }
25248
25249
25250 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj = 0;
25252 wxWindow *arg1 = (wxWindow *) 0 ;
25253 bool result;
25254 void *argp1 = 0 ;
25255 int res1 = 0 ;
25256 PyObject * obj0 = 0 ;
25257 char * kwnames[] = {
25258 (char *) "win", NULL
25259 };
25260
25261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25263 if (!SWIG_IsOK(res1)) {
25264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25265 }
25266 arg1 = reinterpret_cast< wxWindow * >(argp1);
25267 {
25268 PyThreadState* __tstate = wxPyBeginAllowThreads();
25269 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25270 wxPyEndAllowThreads(__tstate);
25271 if (PyErr_Occurred()) SWIG_fail;
25272 }
25273 {
25274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25275 }
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25283 PyObject *resultobj = 0;
25284
25285 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 wxUpdateUIEvent::ResetUpdateTime();
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 resultobj = SWIG_Py_Void();
25293 return resultobj;
25294 fail:
25295 return NULL;
25296 }
25297
25298
25299 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25300 PyObject *resultobj = 0;
25301 wxUpdateUIMode arg1 ;
25302 int val1 ;
25303 int ecode1 = 0 ;
25304 PyObject * obj0 = 0 ;
25305 char * kwnames[] = {
25306 (char *) "mode", NULL
25307 };
25308
25309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25310 ecode1 = SWIG_AsVal_int(obj0, &val1);
25311 if (!SWIG_IsOK(ecode1)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25313 }
25314 arg1 = static_cast< wxUpdateUIMode >(val1);
25315 {
25316 PyThreadState* __tstate = wxPyBeginAllowThreads();
25317 wxUpdateUIEvent::SetMode(arg1);
25318 wxPyEndAllowThreads(__tstate);
25319 if (PyErr_Occurred()) SWIG_fail;
25320 }
25321 resultobj = SWIG_Py_Void();
25322 return resultobj;
25323 fail:
25324 return NULL;
25325 }
25326
25327
25328 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25329 PyObject *resultobj = 0;
25330 wxUpdateUIMode result;
25331
25332 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25336 wxPyEndAllowThreads(__tstate);
25337 if (PyErr_Occurred()) SWIG_fail;
25338 }
25339 resultobj = SWIG_From_int(static_cast< int >(result));
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 PyObject *obj;
25348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25349 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25350 return SWIG_Py_Void();
25351 }
25352
25353 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 return SWIG_Python_InitShadowInstance(args);
25355 }
25356
25357 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25358 PyObject *resultobj = 0;
25359 wxSysColourChangedEvent *result = 0 ;
25360
25361 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25369 return resultobj;
25370 fail:
25371 return NULL;
25372 }
25373
25374
25375 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25376 PyObject *obj;
25377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25378 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25379 return SWIG_Py_Void();
25380 }
25381
25382 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25383 return SWIG_Python_InitShadowInstance(args);
25384 }
25385
25386 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25387 PyObject *resultobj = 0;
25388 int arg1 = (int) 0 ;
25389 wxWindow *arg2 = (wxWindow *) NULL ;
25390 wxMouseCaptureChangedEvent *result = 0 ;
25391 int val1 ;
25392 int ecode1 = 0 ;
25393 void *argp2 = 0 ;
25394 int res2 = 0 ;
25395 PyObject * obj0 = 0 ;
25396 PyObject * obj1 = 0 ;
25397 char * kwnames[] = {
25398 (char *) "winid",(char *) "gainedCapture", NULL
25399 };
25400
25401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25402 if (obj0) {
25403 ecode1 = SWIG_AsVal_int(obj0, &val1);
25404 if (!SWIG_IsOK(ecode1)) {
25405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25406 }
25407 arg1 = static_cast< int >(val1);
25408 }
25409 if (obj1) {
25410 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25411 if (!SWIG_IsOK(res2)) {
25412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25413 }
25414 arg2 = reinterpret_cast< wxWindow * >(argp2);
25415 }
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *resultobj = 0;
25431 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25432 wxWindow *result = 0 ;
25433 void *argp1 = 0 ;
25434 int res1 = 0 ;
25435 PyObject *swig_obj[1] ;
25436
25437 if (!args) SWIG_fail;
25438 swig_obj[0] = args;
25439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25440 if (!SWIG_IsOK(res1)) {
25441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25442 }
25443 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25447 wxPyEndAllowThreads(__tstate);
25448 if (PyErr_Occurred()) SWIG_fail;
25449 }
25450 {
25451 resultobj = wxPyMake_wxObject(result, (bool)0);
25452 }
25453 return resultobj;
25454 fail:
25455 return NULL;
25456 }
25457
25458
25459 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25460 PyObject *obj;
25461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25462 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25463 return SWIG_Py_Void();
25464 }
25465
25466 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25467 return SWIG_Python_InitShadowInstance(args);
25468 }
25469
25470 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25471 PyObject *resultobj = 0;
25472 int arg1 = (int) 0 ;
25473 wxMouseCaptureLostEvent *result = 0 ;
25474 int val1 ;
25475 int ecode1 = 0 ;
25476 PyObject * obj0 = 0 ;
25477 char * kwnames[] = {
25478 (char *) "winid", NULL
25479 };
25480
25481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25482 if (obj0) {
25483 ecode1 = SWIG_AsVal_int(obj0, &val1);
25484 if (!SWIG_IsOK(ecode1)) {
25485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25486 }
25487 arg1 = static_cast< int >(val1);
25488 }
25489 {
25490 PyThreadState* __tstate = wxPyBeginAllowThreads();
25491 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25492 wxPyEndAllowThreads(__tstate);
25493 if (PyErr_Occurred()) SWIG_fail;
25494 }
25495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25503 PyObject *obj;
25504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25505 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25506 return SWIG_Py_Void();
25507 }
25508
25509 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25510 return SWIG_Python_InitShadowInstance(args);
25511 }
25512
25513 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514 PyObject *resultobj = 0;
25515 wxDisplayChangedEvent *result = 0 ;
25516
25517 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25518 {
25519 PyThreadState* __tstate = wxPyBeginAllowThreads();
25520 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25521 wxPyEndAllowThreads(__tstate);
25522 if (PyErr_Occurred()) SWIG_fail;
25523 }
25524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25525 return resultobj;
25526 fail:
25527 return NULL;
25528 }
25529
25530
25531 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25532 PyObject *obj;
25533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25534 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25535 return SWIG_Py_Void();
25536 }
25537
25538 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25539 return SWIG_Python_InitShadowInstance(args);
25540 }
25541
25542 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25543 PyObject *resultobj = 0;
25544 int arg1 = (int) 0 ;
25545 wxPaletteChangedEvent *result = 0 ;
25546 int val1 ;
25547 int ecode1 = 0 ;
25548 PyObject * obj0 = 0 ;
25549 char * kwnames[] = {
25550 (char *) "id", NULL
25551 };
25552
25553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25554 if (obj0) {
25555 ecode1 = SWIG_AsVal_int(obj0, &val1);
25556 if (!SWIG_IsOK(ecode1)) {
25557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25558 }
25559 arg1 = static_cast< int >(val1);
25560 }
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25568 return resultobj;
25569 fail:
25570 return NULL;
25571 }
25572
25573
25574 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25575 PyObject *resultobj = 0;
25576 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25577 wxWindow *arg2 = (wxWindow *) 0 ;
25578 void *argp1 = 0 ;
25579 int res1 = 0 ;
25580 void *argp2 = 0 ;
25581 int res2 = 0 ;
25582 PyObject * obj0 = 0 ;
25583 PyObject * obj1 = 0 ;
25584 char * kwnames[] = {
25585 (char *) "self",(char *) "win", NULL
25586 };
25587
25588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25592 }
25593 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25595 if (!SWIG_IsOK(res2)) {
25596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25597 }
25598 arg2 = reinterpret_cast< wxWindow * >(argp2);
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 (arg1)->SetChangedWindow(arg2);
25602 wxPyEndAllowThreads(__tstate);
25603 if (PyErr_Occurred()) SWIG_fail;
25604 }
25605 resultobj = SWIG_Py_Void();
25606 return resultobj;
25607 fail:
25608 return NULL;
25609 }
25610
25611
25612 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25613 PyObject *resultobj = 0;
25614 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25615 wxWindow *result = 0 ;
25616 void *argp1 = 0 ;
25617 int res1 = 0 ;
25618 PyObject *swig_obj[1] ;
25619
25620 if (!args) SWIG_fail;
25621 swig_obj[0] = args;
25622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25623 if (!SWIG_IsOK(res1)) {
25624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25625 }
25626 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (wxWindow *)(arg1)->GetChangedWindow();
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 {
25634 resultobj = wxPyMake_wxObject(result, (bool)0);
25635 }
25636 return resultobj;
25637 fail:
25638 return NULL;
25639 }
25640
25641
25642 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25643 PyObject *obj;
25644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25645 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25646 return SWIG_Py_Void();
25647 }
25648
25649 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 return SWIG_Python_InitShadowInstance(args);
25651 }
25652
25653 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25654 PyObject *resultobj = 0;
25655 int arg1 = (int) 0 ;
25656 wxQueryNewPaletteEvent *result = 0 ;
25657 int val1 ;
25658 int ecode1 = 0 ;
25659 PyObject * obj0 = 0 ;
25660 char * kwnames[] = {
25661 (char *) "winid", NULL
25662 };
25663
25664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25665 if (obj0) {
25666 ecode1 = SWIG_AsVal_int(obj0, &val1);
25667 if (!SWIG_IsOK(ecode1)) {
25668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25669 }
25670 arg1 = static_cast< int >(val1);
25671 }
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25686 PyObject *resultobj = 0;
25687 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25688 bool arg2 ;
25689 void *argp1 = 0 ;
25690 int res1 = 0 ;
25691 bool val2 ;
25692 int ecode2 = 0 ;
25693 PyObject * obj0 = 0 ;
25694 PyObject * obj1 = 0 ;
25695 char * kwnames[] = {
25696 (char *) "self",(char *) "realized", NULL
25697 };
25698
25699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25701 if (!SWIG_IsOK(res1)) {
25702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25703 }
25704 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25705 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25706 if (!SWIG_IsOK(ecode2)) {
25707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25708 }
25709 arg2 = static_cast< bool >(val2);
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 (arg1)->SetPaletteRealized(arg2);
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 resultobj = SWIG_Py_Void();
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25724 PyObject *resultobj = 0;
25725 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25726 bool result;
25727 void *argp1 = 0 ;
25728 int res1 = 0 ;
25729 PyObject *swig_obj[1] ;
25730
25731 if (!args) SWIG_fail;
25732 swig_obj[0] = args;
25733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25734 if (!SWIG_IsOK(res1)) {
25735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25736 }
25737 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 {
25745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25746 }
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *obj;
25755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25756 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25757 return SWIG_Py_Void();
25758 }
25759
25760 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25761 return SWIG_Python_InitShadowInstance(args);
25762 }
25763
25764 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25765 PyObject *resultobj = 0;
25766 wxNavigationKeyEvent *result = 0 ;
25767
25768 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25769 {
25770 PyThreadState* __tstate = wxPyBeginAllowThreads();
25771 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25772 wxPyEndAllowThreads(__tstate);
25773 if (PyErr_Occurred()) SWIG_fail;
25774 }
25775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25776 return resultobj;
25777 fail:
25778 return NULL;
25779 }
25780
25781
25782 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25783 PyObject *resultobj = 0;
25784 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25785 bool result;
25786 void *argp1 = 0 ;
25787 int res1 = 0 ;
25788 PyObject *swig_obj[1] ;
25789
25790 if (!args) SWIG_fail;
25791 swig_obj[0] = args;
25792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25793 if (!SWIG_IsOK(res1)) {
25794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25795 }
25796 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25797 {
25798 PyThreadState* __tstate = wxPyBeginAllowThreads();
25799 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25800 wxPyEndAllowThreads(__tstate);
25801 if (PyErr_Occurred()) SWIG_fail;
25802 }
25803 {
25804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25805 }
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj = 0;
25814 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25815 bool arg2 ;
25816 void *argp1 = 0 ;
25817 int res1 = 0 ;
25818 bool val2 ;
25819 int ecode2 = 0 ;
25820 PyObject * obj0 = 0 ;
25821 PyObject * obj1 = 0 ;
25822 char * kwnames[] = {
25823 (char *) "self",(char *) "forward", NULL
25824 };
25825
25826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25828 if (!SWIG_IsOK(res1)) {
25829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25830 }
25831 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25832 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25833 if (!SWIG_IsOK(ecode2)) {
25834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25835 }
25836 arg2 = static_cast< bool >(val2);
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 (arg1)->SetDirection(arg2);
25840 wxPyEndAllowThreads(__tstate);
25841 if (PyErr_Occurred()) SWIG_fail;
25842 }
25843 resultobj = SWIG_Py_Void();
25844 return resultobj;
25845 fail:
25846 return NULL;
25847 }
25848
25849
25850 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25851 PyObject *resultobj = 0;
25852 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25853 bool result;
25854 void *argp1 = 0 ;
25855 int res1 = 0 ;
25856 PyObject *swig_obj[1] ;
25857
25858 if (!args) SWIG_fail;
25859 swig_obj[0] = args;
25860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25861 if (!SWIG_IsOK(res1)) {
25862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25863 }
25864 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25865 {
25866 PyThreadState* __tstate = wxPyBeginAllowThreads();
25867 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25868 wxPyEndAllowThreads(__tstate);
25869 if (PyErr_Occurred()) SWIG_fail;
25870 }
25871 {
25872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25873 }
25874 return resultobj;
25875 fail:
25876 return NULL;
25877 }
25878
25879
25880 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj = 0;
25882 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25883 bool arg2 ;
25884 void *argp1 = 0 ;
25885 int res1 = 0 ;
25886 bool val2 ;
25887 int ecode2 = 0 ;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 char * kwnames[] = {
25891 (char *) "self",(char *) "ischange", NULL
25892 };
25893
25894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25896 if (!SWIG_IsOK(res1)) {
25897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25898 }
25899 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25901 if (!SWIG_IsOK(ecode2)) {
25902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25903 }
25904 arg2 = static_cast< bool >(val2);
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 (arg1)->SetWindowChange(arg2);
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_Py_Void();
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 PyObject *resultobj = 0;
25920 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25921 bool result;
25922 void *argp1 = 0 ;
25923 int res1 = 0 ;
25924 PyObject *swig_obj[1] ;
25925
25926 if (!args) SWIG_fail;
25927 swig_obj[0] = args;
25928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25929 if (!SWIG_IsOK(res1)) {
25930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25931 }
25932 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 {
25940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25941 }
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj = 0;
25950 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25951 bool arg2 ;
25952 void *argp1 = 0 ;
25953 int res1 = 0 ;
25954 bool val2 ;
25955 int ecode2 = 0 ;
25956 PyObject * obj0 = 0 ;
25957 PyObject * obj1 = 0 ;
25958 char * kwnames[] = {
25959 (char *) "self",(char *) "bIs", NULL
25960 };
25961
25962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25964 if (!SWIG_IsOK(res1)) {
25965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25966 }
25967 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25969 if (!SWIG_IsOK(ecode2)) {
25970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25971 }
25972 arg2 = static_cast< bool >(val2);
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 (arg1)->SetFromTab(arg2);
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_Py_Void();
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj = 0;
25988 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25989 long arg2 ;
25990 void *argp1 = 0 ;
25991 int res1 = 0 ;
25992 long val2 ;
25993 int ecode2 = 0 ;
25994 PyObject * obj0 = 0 ;
25995 PyObject * obj1 = 0 ;
25996 char * kwnames[] = {
25997 (char *) "self",(char *) "flags", NULL
25998 };
25999
26000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26002 if (!SWIG_IsOK(res1)) {
26003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26004 }
26005 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26006 ecode2 = SWIG_AsVal_long(obj1, &val2);
26007 if (!SWIG_IsOK(ecode2)) {
26008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26009 }
26010 arg2 = static_cast< long >(val2);
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 (arg1)->SetFlags(arg2);
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 resultobj = SWIG_Py_Void();
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26025 PyObject *resultobj = 0;
26026 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26027 wxWindow *result = 0 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 PyObject *swig_obj[1] ;
26031
26032 if (!args) SWIG_fail;
26033 swig_obj[0] = args;
26034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26035 if (!SWIG_IsOK(res1)) {
26036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26037 }
26038 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26042 wxPyEndAllowThreads(__tstate);
26043 if (PyErr_Occurred()) SWIG_fail;
26044 }
26045 {
26046 resultobj = wxPyMake_wxObject(result, (bool)0);
26047 }
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj = 0;
26056 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26057 wxWindow *arg2 = (wxWindow *) 0 ;
26058 void *argp1 = 0 ;
26059 int res1 = 0 ;
26060 void *argp2 = 0 ;
26061 int res2 = 0 ;
26062 PyObject * obj0 = 0 ;
26063 PyObject * obj1 = 0 ;
26064 char * kwnames[] = {
26065 (char *) "self",(char *) "win", NULL
26066 };
26067
26068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26070 if (!SWIG_IsOK(res1)) {
26071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26072 }
26073 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26075 if (!SWIG_IsOK(res2)) {
26076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26077 }
26078 arg2 = reinterpret_cast< wxWindow * >(argp2);
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 (arg1)->SetCurrentFocus(arg2);
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 resultobj = SWIG_Py_Void();
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *obj;
26094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26095 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26096 return SWIG_Py_Void();
26097 }
26098
26099 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26100 return SWIG_Python_InitShadowInstance(args);
26101 }
26102
26103 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26104 PyObject *resultobj = 0;
26105 wxWindow *arg1 = (wxWindow *) NULL ;
26106 wxWindowCreateEvent *result = 0 ;
26107 void *argp1 = 0 ;
26108 int res1 = 0 ;
26109 PyObject * obj0 = 0 ;
26110 char * kwnames[] = {
26111 (char *) "win", NULL
26112 };
26113
26114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26115 if (obj0) {
26116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26119 }
26120 arg1 = reinterpret_cast< wxWindow * >(argp1);
26121 }
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26129 return resultobj;
26130 fail:
26131 return NULL;
26132 }
26133
26134
26135 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26136 PyObject *resultobj = 0;
26137 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26138 wxWindow *result = 0 ;
26139 void *argp1 = 0 ;
26140 int res1 = 0 ;
26141 PyObject *swig_obj[1] ;
26142
26143 if (!args) SWIG_fail;
26144 swig_obj[0] = args;
26145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26146 if (!SWIG_IsOK(res1)) {
26147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26148 }
26149 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 {
26157 resultobj = wxPyMake_wxObject(result, (bool)0);
26158 }
26159 return resultobj;
26160 fail:
26161 return NULL;
26162 }
26163
26164
26165 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 PyObject *obj;
26167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26168 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26169 return SWIG_Py_Void();
26170 }
26171
26172 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26173 return SWIG_Python_InitShadowInstance(args);
26174 }
26175
26176 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26177 PyObject *resultobj = 0;
26178 wxWindow *arg1 = (wxWindow *) NULL ;
26179 wxWindowDestroyEvent *result = 0 ;
26180 void *argp1 = 0 ;
26181 int res1 = 0 ;
26182 PyObject * obj0 = 0 ;
26183 char * kwnames[] = {
26184 (char *) "win", NULL
26185 };
26186
26187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26188 if (obj0) {
26189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26190 if (!SWIG_IsOK(res1)) {
26191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26192 }
26193 arg1 = reinterpret_cast< wxWindow * >(argp1);
26194 }
26195 {
26196 PyThreadState* __tstate = wxPyBeginAllowThreads();
26197 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26198 wxPyEndAllowThreads(__tstate);
26199 if (PyErr_Occurred()) SWIG_fail;
26200 }
26201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26209 PyObject *resultobj = 0;
26210 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26211 wxWindow *result = 0 ;
26212 void *argp1 = 0 ;
26213 int res1 = 0 ;
26214 PyObject *swig_obj[1] ;
26215
26216 if (!args) SWIG_fail;
26217 swig_obj[0] = args;
26218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26219 if (!SWIG_IsOK(res1)) {
26220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26221 }
26222 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26223 {
26224 PyThreadState* __tstate = wxPyBeginAllowThreads();
26225 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 {
26230 resultobj = wxPyMake_wxObject(result, (bool)0);
26231 }
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26239 PyObject *obj;
26240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26241 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26242 return SWIG_Py_Void();
26243 }
26244
26245 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26246 return SWIG_Python_InitShadowInstance(args);
26247 }
26248
26249 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj = 0;
26251 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26252 int arg2 = (int) 0 ;
26253 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26254 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26255 wxContextMenuEvent *result = 0 ;
26256 int val1 ;
26257 int ecode1 = 0 ;
26258 int val2 ;
26259 int ecode2 = 0 ;
26260 wxPoint temp3 ;
26261 PyObject * obj0 = 0 ;
26262 PyObject * obj1 = 0 ;
26263 PyObject * obj2 = 0 ;
26264 char * kwnames[] = {
26265 (char *) "type",(char *) "winid",(char *) "pt", NULL
26266 };
26267
26268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26269 if (obj0) {
26270 ecode1 = SWIG_AsVal_int(obj0, &val1);
26271 if (!SWIG_IsOK(ecode1)) {
26272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26273 }
26274 arg1 = static_cast< wxEventType >(val1);
26275 }
26276 if (obj1) {
26277 ecode2 = SWIG_AsVal_int(obj1, &val2);
26278 if (!SWIG_IsOK(ecode2)) {
26279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26280 }
26281 arg2 = static_cast< int >(val2);
26282 }
26283 if (obj2) {
26284 {
26285 arg3 = &temp3;
26286 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26287 }
26288 }
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 PyObject *resultobj = 0;
26304 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26305 wxPoint *result = 0 ;
26306 void *argp1 = 0 ;
26307 int res1 = 0 ;
26308 PyObject *swig_obj[1] ;
26309
26310 if (!args) SWIG_fail;
26311 swig_obj[0] = args;
26312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26313 if (!SWIG_IsOK(res1)) {
26314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26315 }
26316 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 {
26320 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26321 result = (wxPoint *) &_result_ref;
26322 }
26323 wxPyEndAllowThreads(__tstate);
26324 if (PyErr_Occurred()) SWIG_fail;
26325 }
26326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26327 return resultobj;
26328 fail:
26329 return NULL;
26330 }
26331
26332
26333 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26334 PyObject *resultobj = 0;
26335 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26336 wxPoint *arg2 = 0 ;
26337 void *argp1 = 0 ;
26338 int res1 = 0 ;
26339 wxPoint temp2 ;
26340 PyObject * obj0 = 0 ;
26341 PyObject * obj1 = 0 ;
26342 char * kwnames[] = {
26343 (char *) "self",(char *) "pos", NULL
26344 };
26345
26346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26348 if (!SWIG_IsOK(res1)) {
26349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26350 }
26351 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26352 {
26353 arg2 = &temp2;
26354 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26355 }
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 (arg1)->SetPosition((wxPoint const &)*arg2);
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 resultobj = SWIG_Py_Void();
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26370 PyObject *obj;
26371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26372 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26373 return SWIG_Py_Void();
26374 }
26375
26376 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26377 return SWIG_Python_InitShadowInstance(args);
26378 }
26379
26380 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26381 PyObject *resultobj = 0;
26382 wxIdleEvent *result = 0 ;
26383
26384 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26385 {
26386 PyThreadState* __tstate = wxPyBeginAllowThreads();
26387 result = (wxIdleEvent *)new wxIdleEvent();
26388 wxPyEndAllowThreads(__tstate);
26389 if (PyErr_Occurred()) SWIG_fail;
26390 }
26391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26392 return resultobj;
26393 fail:
26394 return NULL;
26395 }
26396
26397
26398 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26399 PyObject *resultobj = 0;
26400 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26401 bool arg2 = (bool) true ;
26402 void *argp1 = 0 ;
26403 int res1 = 0 ;
26404 bool val2 ;
26405 int ecode2 = 0 ;
26406 PyObject * obj0 = 0 ;
26407 PyObject * obj1 = 0 ;
26408 char * kwnames[] = {
26409 (char *) "self",(char *) "needMore", NULL
26410 };
26411
26412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26414 if (!SWIG_IsOK(res1)) {
26415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26416 }
26417 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26418 if (obj1) {
26419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26420 if (!SWIG_IsOK(ecode2)) {
26421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26422 }
26423 arg2 = static_cast< bool >(val2);
26424 }
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 (arg1)->RequestMore(arg2);
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 resultobj = SWIG_Py_Void();
26432 return resultobj;
26433 fail:
26434 return NULL;
26435 }
26436
26437
26438 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26439 PyObject *resultobj = 0;
26440 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26441 bool result;
26442 void *argp1 = 0 ;
26443 int res1 = 0 ;
26444 PyObject *swig_obj[1] ;
26445
26446 if (!args) SWIG_fail;
26447 swig_obj[0] = args;
26448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26449 if (!SWIG_IsOK(res1)) {
26450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26451 }
26452 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26456 wxPyEndAllowThreads(__tstate);
26457 if (PyErr_Occurred()) SWIG_fail;
26458 }
26459 {
26460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26461 }
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj = 0;
26470 wxIdleMode arg1 ;
26471 int val1 ;
26472 int ecode1 = 0 ;
26473 PyObject * obj0 = 0 ;
26474 char * kwnames[] = {
26475 (char *) "mode", NULL
26476 };
26477
26478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26479 ecode1 = SWIG_AsVal_int(obj0, &val1);
26480 if (!SWIG_IsOK(ecode1)) {
26481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26482 }
26483 arg1 = static_cast< wxIdleMode >(val1);
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 wxIdleEvent::SetMode(arg1);
26487 wxPyEndAllowThreads(__tstate);
26488 if (PyErr_Occurred()) SWIG_fail;
26489 }
26490 resultobj = SWIG_Py_Void();
26491 return resultobj;
26492 fail:
26493 return NULL;
26494 }
26495
26496
26497 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26498 PyObject *resultobj = 0;
26499 wxIdleMode result;
26500
26501 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 result = (wxIdleMode)wxIdleEvent::GetMode();
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 resultobj = SWIG_From_int(static_cast< int >(result));
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj = 0;
26517 wxWindow *arg1 = (wxWindow *) 0 ;
26518 bool result;
26519 void *argp1 = 0 ;
26520 int res1 = 0 ;
26521 PyObject * obj0 = 0 ;
26522 char * kwnames[] = {
26523 (char *) "win", NULL
26524 };
26525
26526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26528 if (!SWIG_IsOK(res1)) {
26529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26530 }
26531 arg1 = reinterpret_cast< wxWindow * >(argp1);
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = (bool)wxIdleEvent::CanSend(arg1);
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 {
26539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26540 }
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *obj;
26549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26550 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26551 return SWIG_Py_Void();
26552 }
26553
26554 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26555 return SWIG_Python_InitShadowInstance(args);
26556 }
26557
26558 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26559 PyObject *resultobj = 0;
26560 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26561 int arg2 = (int) 0 ;
26562 wxClipboardTextEvent *result = 0 ;
26563 int val1 ;
26564 int ecode1 = 0 ;
26565 int val2 ;
26566 int ecode2 = 0 ;
26567 PyObject * obj0 = 0 ;
26568 PyObject * obj1 = 0 ;
26569 char * kwnames[] = {
26570 (char *) "type",(char *) "winid", NULL
26571 };
26572
26573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26574 if (obj0) {
26575 ecode1 = SWIG_AsVal_int(obj0, &val1);
26576 if (!SWIG_IsOK(ecode1)) {
26577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26578 }
26579 arg1 = static_cast< wxEventType >(val1);
26580 }
26581 if (obj1) {
26582 ecode2 = SWIG_AsVal_int(obj1, &val2);
26583 if (!SWIG_IsOK(ecode2)) {
26584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26585 }
26586 arg2 = static_cast< int >(val2);
26587 }
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26595 return resultobj;
26596 fail:
26597 return NULL;
26598 }
26599
26600
26601 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26602 PyObject *obj;
26603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26604 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26605 return SWIG_Py_Void();
26606 }
26607
26608 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609 return SWIG_Python_InitShadowInstance(args);
26610 }
26611
26612 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26613 PyObject *resultobj = 0;
26614 int arg1 = (int) 0 ;
26615 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26616 wxPyEvent *result = 0 ;
26617 int val1 ;
26618 int ecode1 = 0 ;
26619 int val2 ;
26620 int ecode2 = 0 ;
26621 PyObject * obj0 = 0 ;
26622 PyObject * obj1 = 0 ;
26623 char * kwnames[] = {
26624 (char *) "winid",(char *) "eventType", NULL
26625 };
26626
26627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26628 if (obj0) {
26629 ecode1 = SWIG_AsVal_int(obj0, &val1);
26630 if (!SWIG_IsOK(ecode1)) {
26631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26632 }
26633 arg1 = static_cast< int >(val1);
26634 }
26635 if (obj1) {
26636 ecode2 = SWIG_AsVal_int(obj1, &val2);
26637 if (!SWIG_IsOK(ecode2)) {
26638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26639 }
26640 arg2 = static_cast< wxEventType >(val2);
26641 }
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 PyObject *resultobj = 0;
26657 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26658 void *argp1 = 0 ;
26659 int res1 = 0 ;
26660 PyObject *swig_obj[1] ;
26661
26662 if (!args) SWIG_fail;
26663 swig_obj[0] = args;
26664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26665 if (!SWIG_IsOK(res1)) {
26666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26667 }
26668 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 delete arg1;
26672
26673 wxPyEndAllowThreads(__tstate);
26674 if (PyErr_Occurred()) SWIG_fail;
26675 }
26676 resultobj = SWIG_Py_Void();
26677 return resultobj;
26678 fail:
26679 return NULL;
26680 }
26681
26682
26683 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26684 PyObject *resultobj = 0;
26685 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26686 PyObject *arg2 = (PyObject *) 0 ;
26687 void *argp1 = 0 ;
26688 int res1 = 0 ;
26689 PyObject * obj0 = 0 ;
26690 PyObject * obj1 = 0 ;
26691 char * kwnames[] = {
26692 (char *) "self",(char *) "self", NULL
26693 };
26694
26695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26697 if (!SWIG_IsOK(res1)) {
26698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26699 }
26700 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26701 arg2 = obj1;
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 (arg1)->SetSelf(arg2);
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 resultobj = SWIG_Py_Void();
26709 return resultobj;
26710 fail:
26711 return NULL;
26712 }
26713
26714
26715 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 PyObject *resultobj = 0;
26717 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26718 PyObject *result = 0 ;
26719 void *argp1 = 0 ;
26720 int res1 = 0 ;
26721 PyObject *swig_obj[1] ;
26722
26723 if (!args) SWIG_fail;
26724 swig_obj[0] = args;
26725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26726 if (!SWIG_IsOK(res1)) {
26727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26728 }
26729 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26730 {
26731 PyThreadState* __tstate = wxPyBeginAllowThreads();
26732 result = (PyObject *)(arg1)->GetSelf();
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 resultobj = result;
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744 PyObject *obj;
26745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26746 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26747 return SWIG_Py_Void();
26748 }
26749
26750 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26751 return SWIG_Python_InitShadowInstance(args);
26752 }
26753
26754 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26755 PyObject *resultobj = 0;
26756 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26757 int arg2 = (int) 0 ;
26758 wxPyCommandEvent *result = 0 ;
26759 int val1 ;
26760 int ecode1 = 0 ;
26761 int val2 ;
26762 int ecode2 = 0 ;
26763 PyObject * obj0 = 0 ;
26764 PyObject * obj1 = 0 ;
26765 char * kwnames[] = {
26766 (char *) "eventType",(char *) "id", NULL
26767 };
26768
26769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26770 if (obj0) {
26771 ecode1 = SWIG_AsVal_int(obj0, &val1);
26772 if (!SWIG_IsOK(ecode1)) {
26773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26774 }
26775 arg1 = static_cast< wxEventType >(val1);
26776 }
26777 if (obj1) {
26778 ecode2 = SWIG_AsVal_int(obj1, &val2);
26779 if (!SWIG_IsOK(ecode2)) {
26780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26781 }
26782 arg2 = static_cast< int >(val2);
26783 }
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 PyObject *resultobj = 0;
26799 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26800 void *argp1 = 0 ;
26801 int res1 = 0 ;
26802 PyObject *swig_obj[1] ;
26803
26804 if (!args) SWIG_fail;
26805 swig_obj[0] = args;
26806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26807 if (!SWIG_IsOK(res1)) {
26808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26809 }
26810 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26811 {
26812 PyThreadState* __tstate = wxPyBeginAllowThreads();
26813 delete arg1;
26814
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 resultobj = SWIG_Py_Void();
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26826 PyObject *resultobj = 0;
26827 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26828 PyObject *arg2 = (PyObject *) 0 ;
26829 void *argp1 = 0 ;
26830 int res1 = 0 ;
26831 PyObject * obj0 = 0 ;
26832 PyObject * obj1 = 0 ;
26833 char * kwnames[] = {
26834 (char *) "self",(char *) "self", NULL
26835 };
26836
26837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26839 if (!SWIG_IsOK(res1)) {
26840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26841 }
26842 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26843 arg2 = obj1;
26844 {
26845 PyThreadState* __tstate = wxPyBeginAllowThreads();
26846 (arg1)->SetSelf(arg2);
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 resultobj = SWIG_Py_Void();
26851 return resultobj;
26852 fail:
26853 return NULL;
26854 }
26855
26856
26857 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26858 PyObject *resultobj = 0;
26859 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26860 PyObject *result = 0 ;
26861 void *argp1 = 0 ;
26862 int res1 = 0 ;
26863 PyObject *swig_obj[1] ;
26864
26865 if (!args) SWIG_fail;
26866 swig_obj[0] = args;
26867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26870 }
26871 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 result = (PyObject *)(arg1)->GetSelf();
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 resultobj = result;
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26886 PyObject *obj;
26887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26888 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26889 return SWIG_Py_Void();
26890 }
26891
26892 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26893 return SWIG_Python_InitShadowInstance(args);
26894 }
26895
26896 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj = 0;
26898 wxWindow *arg1 = (wxWindow *) 0 ;
26899 wxDateTime *arg2 = 0 ;
26900 wxEventType arg3 ;
26901 wxDateEvent *result = 0 ;
26902 void *argp1 = 0 ;
26903 int res1 = 0 ;
26904 void *argp2 = 0 ;
26905 int res2 = 0 ;
26906 int val3 ;
26907 int ecode3 = 0 ;
26908 PyObject * obj0 = 0 ;
26909 PyObject * obj1 = 0 ;
26910 PyObject * obj2 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "win",(char *) "dt",(char *) "type", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26917 if (!SWIG_IsOK(res1)) {
26918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26919 }
26920 arg1 = reinterpret_cast< wxWindow * >(argp1);
26921 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26922 if (!SWIG_IsOK(res2)) {
26923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26924 }
26925 if (!argp2) {
26926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26927 }
26928 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26929 ecode3 = SWIG_AsVal_int(obj2, &val3);
26930 if (!SWIG_IsOK(ecode3)) {
26931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26932 }
26933 arg3 = static_cast< wxEventType >(val3);
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26937 wxPyEndAllowThreads(__tstate);
26938 if (PyErr_Occurred()) SWIG_fail;
26939 }
26940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 PyObject *resultobj = 0;
26949 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26950 wxDateTime *result = 0 ;
26951 void *argp1 = 0 ;
26952 int res1 = 0 ;
26953 PyObject *swig_obj[1] ;
26954
26955 if (!args) SWIG_fail;
26956 swig_obj[0] = args;
26957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26960 }
26961 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 {
26965 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26966 result = (wxDateTime *) &_result_ref;
26967 }
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26972 return resultobj;
26973 fail:
26974 return NULL;
26975 }
26976
26977
26978 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26979 PyObject *resultobj = 0;
26980 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26981 wxDateTime *arg2 = 0 ;
26982 void *argp1 = 0 ;
26983 int res1 = 0 ;
26984 void *argp2 = 0 ;
26985 int res2 = 0 ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char * kwnames[] = {
26989 (char *) "self",(char *) "date", NULL
26990 };
26991
26992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26994 if (!SWIG_IsOK(res1)) {
26995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26996 }
26997 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26999 if (!SWIG_IsOK(res2)) {
27000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27001 }
27002 if (!argp2) {
27003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27004 }
27005 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27006 {
27007 PyThreadState* __tstate = wxPyBeginAllowThreads();
27008 (arg1)->SetDate((wxDateTime const &)*arg2);
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 resultobj = SWIG_Py_Void();
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27020 PyObject *obj;
27021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27022 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27023 return SWIG_Py_Void();
27024 }
27025
27026 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27027 return SWIG_Python_InitShadowInstance(args);
27028 }
27029
27030 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27031 PyObject *resultobj = 0;
27032 wxPyApp *result = 0 ;
27033
27034 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27035 {
27036 PyThreadState* __tstate = wxPyBeginAllowThreads();
27037 result = (wxPyApp *)new_wxPyApp();
27038 wxPyEndAllowThreads(__tstate);
27039 if (PyErr_Occurred()) SWIG_fail;
27040 }
27041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27049 PyObject *resultobj = 0;
27050 wxPyApp *arg1 = (wxPyApp *) 0 ;
27051 void *argp1 = 0 ;
27052 int res1 = 0 ;
27053 PyObject *swig_obj[1] ;
27054
27055 if (!args) SWIG_fail;
27056 swig_obj[0] = args;
27057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27058 if (!SWIG_IsOK(res1)) {
27059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27060 }
27061 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27062 {
27063 PyThreadState* __tstate = wxPyBeginAllowThreads();
27064 delete arg1;
27065
27066 wxPyEndAllowThreads(__tstate);
27067 if (PyErr_Occurred()) SWIG_fail;
27068 }
27069 resultobj = SWIG_Py_Void();
27070 return resultobj;
27071 fail:
27072 return NULL;
27073 }
27074
27075
27076 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27077 PyObject *resultobj = 0;
27078 wxPyApp *arg1 = (wxPyApp *) 0 ;
27079 PyObject *arg2 = (PyObject *) 0 ;
27080 PyObject *arg3 = (PyObject *) 0 ;
27081 bool arg4 ;
27082 void *argp1 = 0 ;
27083 int res1 = 0 ;
27084 bool val4 ;
27085 int ecode4 = 0 ;
27086 PyObject * obj0 = 0 ;
27087 PyObject * obj1 = 0 ;
27088 PyObject * obj2 = 0 ;
27089 PyObject * obj3 = 0 ;
27090 char * kwnames[] = {
27091 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27092 };
27093
27094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27096 if (!SWIG_IsOK(res1)) {
27097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27098 }
27099 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27100 arg2 = obj1;
27101 arg3 = obj2;
27102 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27103 if (!SWIG_IsOK(ecode4)) {
27104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27105 }
27106 arg4 = static_cast< bool >(val4);
27107 {
27108 PyThreadState* __tstate = wxPyBeginAllowThreads();
27109 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27110 wxPyEndAllowThreads(__tstate);
27111 if (PyErr_Occurred()) SWIG_fail;
27112 }
27113 resultobj = SWIG_Py_Void();
27114 return resultobj;
27115 fail:
27116 return NULL;
27117 }
27118
27119
27120 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27121 PyObject *resultobj = 0;
27122 wxPyApp *arg1 = (wxPyApp *) 0 ;
27123 wxString result;
27124 void *argp1 = 0 ;
27125 int res1 = 0 ;
27126 PyObject *swig_obj[1] ;
27127
27128 if (!args) SWIG_fail;
27129 swig_obj[0] = args;
27130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27133 }
27134 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 result = ((wxPyApp const *)arg1)->GetAppName();
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 {
27142 #if wxUSE_UNICODE
27143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27144 #else
27145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27146 #endif
27147 }
27148 return resultobj;
27149 fail:
27150 return NULL;
27151 }
27152
27153
27154 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27155 PyObject *resultobj = 0;
27156 wxPyApp *arg1 = (wxPyApp *) 0 ;
27157 wxString *arg2 = 0 ;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 bool temp2 = false ;
27161 PyObject * obj0 = 0 ;
27162 PyObject * obj1 = 0 ;
27163 char * kwnames[] = {
27164 (char *) "self",(char *) "name", NULL
27165 };
27166
27167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27169 if (!SWIG_IsOK(res1)) {
27170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27171 }
27172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27173 {
27174 arg2 = wxString_in_helper(obj1);
27175 if (arg2 == NULL) SWIG_fail;
27176 temp2 = true;
27177 }
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 (arg1)->SetAppName((wxString const &)*arg2);
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 resultobj = SWIG_Py_Void();
27185 {
27186 if (temp2)
27187 delete arg2;
27188 }
27189 return resultobj;
27190 fail:
27191 {
27192 if (temp2)
27193 delete arg2;
27194 }
27195 return NULL;
27196 }
27197
27198
27199 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27200 PyObject *resultobj = 0;
27201 wxPyApp *arg1 = (wxPyApp *) 0 ;
27202 wxString result;
27203 void *argp1 = 0 ;
27204 int res1 = 0 ;
27205 PyObject *swig_obj[1] ;
27206
27207 if (!args) SWIG_fail;
27208 swig_obj[0] = args;
27209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27210 if (!SWIG_IsOK(res1)) {
27211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27212 }
27213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 result = ((wxPyApp const *)arg1)->GetClassName();
27217 wxPyEndAllowThreads(__tstate);
27218 if (PyErr_Occurred()) SWIG_fail;
27219 }
27220 {
27221 #if wxUSE_UNICODE
27222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27223 #else
27224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27225 #endif
27226 }
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27234 PyObject *resultobj = 0;
27235 wxPyApp *arg1 = (wxPyApp *) 0 ;
27236 wxString *arg2 = 0 ;
27237 void *argp1 = 0 ;
27238 int res1 = 0 ;
27239 bool temp2 = false ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 char * kwnames[] = {
27243 (char *) "self",(char *) "name", NULL
27244 };
27245
27246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27248 if (!SWIG_IsOK(res1)) {
27249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27250 }
27251 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27252 {
27253 arg2 = wxString_in_helper(obj1);
27254 if (arg2 == NULL) SWIG_fail;
27255 temp2 = true;
27256 }
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 (arg1)->SetClassName((wxString const &)*arg2);
27260 wxPyEndAllowThreads(__tstate);
27261 if (PyErr_Occurred()) SWIG_fail;
27262 }
27263 resultobj = SWIG_Py_Void();
27264 {
27265 if (temp2)
27266 delete arg2;
27267 }
27268 return resultobj;
27269 fail:
27270 {
27271 if (temp2)
27272 delete arg2;
27273 }
27274 return NULL;
27275 }
27276
27277
27278 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27279 PyObject *resultobj = 0;
27280 wxPyApp *arg1 = (wxPyApp *) 0 ;
27281 wxString *result = 0 ;
27282 void *argp1 = 0 ;
27283 int res1 = 0 ;
27284 PyObject *swig_obj[1] ;
27285
27286 if (!args) SWIG_fail;
27287 swig_obj[0] = args;
27288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27289 if (!SWIG_IsOK(res1)) {
27290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27291 }
27292 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27293 {
27294 PyThreadState* __tstate = wxPyBeginAllowThreads();
27295 {
27296 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27297 result = (wxString *) &_result_ref;
27298 }
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 {
27303 #if wxUSE_UNICODE
27304 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27305 #else
27306 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27307 #endif
27308 }
27309 return resultobj;
27310 fail:
27311 return NULL;
27312 }
27313
27314
27315 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27316 PyObject *resultobj = 0;
27317 wxPyApp *arg1 = (wxPyApp *) 0 ;
27318 wxString *arg2 = 0 ;
27319 void *argp1 = 0 ;
27320 int res1 = 0 ;
27321 bool temp2 = false ;
27322 PyObject * obj0 = 0 ;
27323 PyObject * obj1 = 0 ;
27324 char * kwnames[] = {
27325 (char *) "self",(char *) "name", NULL
27326 };
27327
27328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27330 if (!SWIG_IsOK(res1)) {
27331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27332 }
27333 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27334 {
27335 arg2 = wxString_in_helper(obj1);
27336 if (arg2 == NULL) SWIG_fail;
27337 temp2 = true;
27338 }
27339 {
27340 PyThreadState* __tstate = wxPyBeginAllowThreads();
27341 (arg1)->SetVendorName((wxString const &)*arg2);
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_Py_Void();
27346 {
27347 if (temp2)
27348 delete arg2;
27349 }
27350 return resultobj;
27351 fail:
27352 {
27353 if (temp2)
27354 delete arg2;
27355 }
27356 return NULL;
27357 }
27358
27359
27360 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27361 PyObject *resultobj = 0;
27362 wxPyApp *arg1 = (wxPyApp *) 0 ;
27363 wxAppTraits *result = 0 ;
27364 void *argp1 = 0 ;
27365 int res1 = 0 ;
27366 PyObject *swig_obj[1] ;
27367
27368 if (!args) SWIG_fail;
27369 swig_obj[0] = args;
27370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27371 if (!SWIG_IsOK(res1)) {
27372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27373 }
27374 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = (wxAppTraits *)(arg1)->GetTraits();
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27389 PyObject *resultobj = 0;
27390 wxPyApp *arg1 = (wxPyApp *) 0 ;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 PyObject *swig_obj[1] ;
27394
27395 if (!args) SWIG_fail;
27396 swig_obj[0] = args;
27397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27398 if (!SWIG_IsOK(res1)) {
27399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27400 }
27401 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 (arg1)->ProcessPendingEvents();
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 resultobj = SWIG_Py_Void();
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj = 0;
27417 wxPyApp *arg1 = (wxPyApp *) 0 ;
27418 bool arg2 = (bool) false ;
27419 bool result;
27420 void *argp1 = 0 ;
27421 int res1 = 0 ;
27422 bool val2 ;
27423 int ecode2 = 0 ;
27424 PyObject * obj0 = 0 ;
27425 PyObject * obj1 = 0 ;
27426 char * kwnames[] = {
27427 (char *) "self",(char *) "onlyIfNeeded", NULL
27428 };
27429
27430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27432 if (!SWIG_IsOK(res1)) {
27433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27434 }
27435 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27436 if (obj1) {
27437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27438 if (!SWIG_IsOK(ecode2)) {
27439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27440 }
27441 arg2 = static_cast< bool >(val2);
27442 }
27443 {
27444 PyThreadState* __tstate = wxPyBeginAllowThreads();
27445 result = (bool)(arg1)->Yield(arg2);
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 {
27450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27451 }
27452 return resultobj;
27453 fail:
27454 return NULL;
27455 }
27456
27457
27458 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27459 PyObject *resultobj = 0;
27460 wxPyApp *arg1 = (wxPyApp *) 0 ;
27461 void *argp1 = 0 ;
27462 int res1 = 0 ;
27463 PyObject *swig_obj[1] ;
27464
27465 if (!args) SWIG_fail;
27466 swig_obj[0] = args;
27467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27468 if (!SWIG_IsOK(res1)) {
27469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27470 }
27471 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 (arg1)->WakeUpIdle();
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = SWIG_Py_Void();
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *resultobj = 0;
27487 bool result;
27488
27489 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 result = (bool)wxPyApp::IsMainLoopRunning();
27493 wxPyEndAllowThreads(__tstate);
27494 if (PyErr_Occurred()) SWIG_fail;
27495 }
27496 {
27497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27498 }
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27506 PyObject *resultobj = 0;
27507 wxPyApp *arg1 = (wxPyApp *) 0 ;
27508 int result;
27509 void *argp1 = 0 ;
27510 int res1 = 0 ;
27511 PyObject *swig_obj[1] ;
27512
27513 if (!args) SWIG_fail;
27514 swig_obj[0] = args;
27515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27516 if (!SWIG_IsOK(res1)) {
27517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27518 }
27519 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 result = (int)(arg1)->MainLoop();
27523 wxPyEndAllowThreads(__tstate);
27524 if (PyErr_Occurred()) SWIG_fail;
27525 }
27526 resultobj = SWIG_From_int(static_cast< int >(result));
27527 return resultobj;
27528 fail:
27529 return NULL;
27530 }
27531
27532
27533 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27534 PyObject *resultobj = 0;
27535 wxPyApp *arg1 = (wxPyApp *) 0 ;
27536 void *argp1 = 0 ;
27537 int res1 = 0 ;
27538 PyObject *swig_obj[1] ;
27539
27540 if (!args) SWIG_fail;
27541 swig_obj[0] = args;
27542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27543 if (!SWIG_IsOK(res1)) {
27544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27545 }
27546 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 (arg1)->Exit();
27550 wxPyEndAllowThreads(__tstate);
27551 if (PyErr_Occurred()) SWIG_fail;
27552 }
27553 resultobj = SWIG_Py_Void();
27554 return resultobj;
27555 fail:
27556 return NULL;
27557 }
27558
27559
27560 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27561 PyObject *resultobj = 0;
27562 wxPyApp *arg1 = (wxPyApp *) 0 ;
27563 void *argp1 = 0 ;
27564 int res1 = 0 ;
27565 PyObject *swig_obj[1] ;
27566
27567 if (!args) SWIG_fail;
27568 swig_obj[0] = args;
27569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27572 }
27573 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27574 {
27575 PyThreadState* __tstate = wxPyBeginAllowThreads();
27576 (arg1)->ExitMainLoop();
27577 wxPyEndAllowThreads(__tstate);
27578 if (PyErr_Occurred()) SWIG_fail;
27579 }
27580 resultobj = SWIG_Py_Void();
27581 return resultobj;
27582 fail:
27583 return NULL;
27584 }
27585
27586
27587 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27588 PyObject *resultobj = 0;
27589 wxPyApp *arg1 = (wxPyApp *) 0 ;
27590 bool result;
27591 void *argp1 = 0 ;
27592 int res1 = 0 ;
27593 PyObject *swig_obj[1] ;
27594
27595 if (!args) SWIG_fail;
27596 swig_obj[0] = args;
27597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27598 if (!SWIG_IsOK(res1)) {
27599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27600 }
27601 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 result = (bool)(arg1)->Pending();
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 {
27609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27610 }
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27618 PyObject *resultobj = 0;
27619 wxPyApp *arg1 = (wxPyApp *) 0 ;
27620 bool result;
27621 void *argp1 = 0 ;
27622 int res1 = 0 ;
27623 PyObject *swig_obj[1] ;
27624
27625 if (!args) SWIG_fail;
27626 swig_obj[0] = args;
27627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27628 if (!SWIG_IsOK(res1)) {
27629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27630 }
27631 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 result = (bool)(arg1)->Dispatch();
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 {
27639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27640 }
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27648 PyObject *resultobj = 0;
27649 wxPyApp *arg1 = (wxPyApp *) 0 ;
27650 bool result;
27651 void *argp1 = 0 ;
27652 int res1 = 0 ;
27653 PyObject *swig_obj[1] ;
27654
27655 if (!args) SWIG_fail;
27656 swig_obj[0] = args;
27657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27658 if (!SWIG_IsOK(res1)) {
27659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27660 }
27661 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27662 {
27663 PyThreadState* __tstate = wxPyBeginAllowThreads();
27664 result = (bool)(arg1)->ProcessIdle();
27665 wxPyEndAllowThreads(__tstate);
27666 if (PyErr_Occurred()) SWIG_fail;
27667 }
27668 {
27669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27670 }
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27678 PyObject *resultobj = 0;
27679 wxPyApp *arg1 = (wxPyApp *) 0 ;
27680 wxWindow *arg2 = (wxWindow *) 0 ;
27681 wxIdleEvent *arg3 = 0 ;
27682 bool result;
27683 void *argp1 = 0 ;
27684 int res1 = 0 ;
27685 void *argp2 = 0 ;
27686 int res2 = 0 ;
27687 void *argp3 = 0 ;
27688 int res3 = 0 ;
27689 PyObject * obj0 = 0 ;
27690 PyObject * obj1 = 0 ;
27691 PyObject * obj2 = 0 ;
27692 char * kwnames[] = {
27693 (char *) "self",(char *) "win",(char *) "event", NULL
27694 };
27695
27696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27698 if (!SWIG_IsOK(res1)) {
27699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27700 }
27701 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27703 if (!SWIG_IsOK(res2)) {
27704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27705 }
27706 arg2 = reinterpret_cast< wxWindow * >(argp2);
27707 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27708 if (!SWIG_IsOK(res3)) {
27709 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27710 }
27711 if (!argp3) {
27712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27713 }
27714 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 {
27722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27723 }
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27731 PyObject *resultobj = 0;
27732 wxPyApp *arg1 = (wxPyApp *) 0 ;
27733 bool result;
27734 void *argp1 = 0 ;
27735 int res1 = 0 ;
27736 PyObject *swig_obj[1] ;
27737
27738 if (!args) SWIG_fail;
27739 swig_obj[0] = args;
27740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27743 }
27744 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (bool)((wxPyApp const *)arg1)->IsActive();
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 {
27752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27753 }
27754 return resultobj;
27755 fail:
27756 return NULL;
27757 }
27758
27759
27760 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27761 PyObject *resultobj = 0;
27762 wxPyApp *arg1 = (wxPyApp *) 0 ;
27763 wxWindow *arg2 = (wxWindow *) 0 ;
27764 void *argp1 = 0 ;
27765 int res1 = 0 ;
27766 void *argp2 = 0 ;
27767 int res2 = 0 ;
27768 PyObject * obj0 = 0 ;
27769 PyObject * obj1 = 0 ;
27770 char * kwnames[] = {
27771 (char *) "self",(char *) "win", NULL
27772 };
27773
27774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27776 if (!SWIG_IsOK(res1)) {
27777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27778 }
27779 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27781 if (!SWIG_IsOK(res2)) {
27782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27783 }
27784 arg2 = reinterpret_cast< wxWindow * >(argp2);
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 (arg1)->SetTopWindow(arg2);
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 resultobj = SWIG_Py_Void();
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27799 PyObject *resultobj = 0;
27800 wxPyApp *arg1 = (wxPyApp *) 0 ;
27801 wxWindow *result = 0 ;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 PyObject *swig_obj[1] ;
27805
27806 if (!args) SWIG_fail;
27807 swig_obj[0] = args;
27808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27811 }
27812 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27816 wxPyEndAllowThreads(__tstate);
27817 if (PyErr_Occurred()) SWIG_fail;
27818 }
27819 {
27820 resultobj = wxPyMake_wxObject(result, (bool)0);
27821 }
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj = 0;
27830 wxPyApp *arg1 = (wxPyApp *) 0 ;
27831 bool arg2 ;
27832 void *argp1 = 0 ;
27833 int res1 = 0 ;
27834 bool val2 ;
27835 int ecode2 = 0 ;
27836 PyObject * obj0 = 0 ;
27837 PyObject * obj1 = 0 ;
27838 char * kwnames[] = {
27839 (char *) "self",(char *) "flag", NULL
27840 };
27841
27842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27846 }
27847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27849 if (!SWIG_IsOK(ecode2)) {
27850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27851 }
27852 arg2 = static_cast< bool >(val2);
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 (arg1)->SetExitOnFrameDelete(arg2);
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 resultobj = SWIG_Py_Void();
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 wxPyApp *arg1 = (wxPyApp *) 0 ;
27869 bool result;
27870 void *argp1 = 0 ;
27871 int res1 = 0 ;
27872 PyObject *swig_obj[1] ;
27873
27874 if (!args) SWIG_fail;
27875 swig_obj[0] = args;
27876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27877 if (!SWIG_IsOK(res1)) {
27878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27879 }
27880 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 {
27888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27889 }
27890 return resultobj;
27891 fail:
27892 return NULL;
27893 }
27894
27895
27896 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27897 PyObject *resultobj = 0;
27898 wxPyApp *arg1 = (wxPyApp *) 0 ;
27899 bool arg2 ;
27900 void *argp1 = 0 ;
27901 int res1 = 0 ;
27902 bool val2 ;
27903 int ecode2 = 0 ;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906 char * kwnames[] = {
27907 (char *) "self",(char *) "flag", NULL
27908 };
27909
27910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27914 }
27915 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27917 if (!SWIG_IsOK(ecode2)) {
27918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27919 }
27920 arg2 = static_cast< bool >(val2);
27921 {
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 (arg1)->SetUseBestVisual(arg2);
27924 wxPyEndAllowThreads(__tstate);
27925 if (PyErr_Occurred()) SWIG_fail;
27926 }
27927 resultobj = SWIG_Py_Void();
27928 return resultobj;
27929 fail:
27930 return NULL;
27931 }
27932
27933
27934 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27935 PyObject *resultobj = 0;
27936 wxPyApp *arg1 = (wxPyApp *) 0 ;
27937 bool result;
27938 void *argp1 = 0 ;
27939 int res1 = 0 ;
27940 PyObject *swig_obj[1] ;
27941
27942 if (!args) SWIG_fail;
27943 swig_obj[0] = args;
27944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27945 if (!SWIG_IsOK(res1)) {
27946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27947 }
27948 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27952 wxPyEndAllowThreads(__tstate);
27953 if (PyErr_Occurred()) SWIG_fail;
27954 }
27955 {
27956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27957 }
27958 return resultobj;
27959 fail:
27960 return NULL;
27961 }
27962
27963
27964 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj = 0;
27966 wxPyApp *arg1 = (wxPyApp *) 0 ;
27967 int arg2 ;
27968 void *argp1 = 0 ;
27969 int res1 = 0 ;
27970 int val2 ;
27971 int ecode2 = 0 ;
27972 PyObject * obj0 = 0 ;
27973 PyObject * obj1 = 0 ;
27974 char * kwnames[] = {
27975 (char *) "self",(char *) "mode", NULL
27976 };
27977
27978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27980 if (!SWIG_IsOK(res1)) {
27981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27982 }
27983 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27984 ecode2 = SWIG_AsVal_int(obj1, &val2);
27985 if (!SWIG_IsOK(ecode2)) {
27986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27987 }
27988 arg2 = static_cast< int >(val2);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 (arg1)->SetPrintMode(arg2);
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 resultobj = SWIG_Py_Void();
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28003 PyObject *resultobj = 0;
28004 wxPyApp *arg1 = (wxPyApp *) 0 ;
28005 int result;
28006 void *argp1 = 0 ;
28007 int res1 = 0 ;
28008 PyObject *swig_obj[1] ;
28009
28010 if (!args) SWIG_fail;
28011 swig_obj[0] = args;
28012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28013 if (!SWIG_IsOK(res1)) {
28014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28015 }
28016 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 resultobj = SWIG_From_int(static_cast< int >(result));
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj = 0;
28032 wxPyApp *arg1 = (wxPyApp *) 0 ;
28033 int arg2 ;
28034 void *argp1 = 0 ;
28035 int res1 = 0 ;
28036 int val2 ;
28037 int ecode2 = 0 ;
28038 PyObject * obj0 = 0 ;
28039 PyObject * obj1 = 0 ;
28040 char * kwnames[] = {
28041 (char *) "self",(char *) "mode", NULL
28042 };
28043
28044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28046 if (!SWIG_IsOK(res1)) {
28047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28048 }
28049 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28050 ecode2 = SWIG_AsVal_int(obj1, &val2);
28051 if (!SWIG_IsOK(ecode2)) {
28052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28053 }
28054 arg2 = static_cast< int >(val2);
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 (arg1)->SetAssertMode(arg2);
28058 wxPyEndAllowThreads(__tstate);
28059 if (PyErr_Occurred()) SWIG_fail;
28060 }
28061 resultobj = SWIG_Py_Void();
28062 return resultobj;
28063 fail:
28064 return NULL;
28065 }
28066
28067
28068 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28069 PyObject *resultobj = 0;
28070 wxPyApp *arg1 = (wxPyApp *) 0 ;
28071 int result;
28072 void *argp1 = 0 ;
28073 int res1 = 0 ;
28074 PyObject *swig_obj[1] ;
28075
28076 if (!args) SWIG_fail;
28077 swig_obj[0] = args;
28078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28079 if (!SWIG_IsOK(res1)) {
28080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28081 }
28082 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 result = (int)(arg1)->GetAssertMode();
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 resultobj = SWIG_From_int(static_cast< int >(result));
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28097 PyObject *resultobj = 0;
28098 bool result;
28099
28100 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28101 {
28102 PyThreadState* __tstate = wxPyBeginAllowThreads();
28103 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 {
28108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28109 }
28110 return resultobj;
28111 fail:
28112 return NULL;
28113 }
28114
28115
28116 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28117 PyObject *resultobj = 0;
28118 long result;
28119
28120 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (long)wxPyApp::GetMacAboutMenuItemId();
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 resultobj = SWIG_From_long(static_cast< long >(result));
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28135 PyObject *resultobj = 0;
28136 long result;
28137
28138 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28139 {
28140 PyThreadState* __tstate = wxPyBeginAllowThreads();
28141 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28142 wxPyEndAllowThreads(__tstate);
28143 if (PyErr_Occurred()) SWIG_fail;
28144 }
28145 resultobj = SWIG_From_long(static_cast< long >(result));
28146 return resultobj;
28147 fail:
28148 return NULL;
28149 }
28150
28151
28152 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28153 PyObject *resultobj = 0;
28154 long result;
28155
28156 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28157 {
28158 PyThreadState* __tstate = wxPyBeginAllowThreads();
28159 result = (long)wxPyApp::GetMacExitMenuItemId();
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 resultobj = SWIG_From_long(static_cast< long >(result));
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28171 PyObject *resultobj = 0;
28172 wxString result;
28173
28174 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 result = wxPyApp::GetMacHelpMenuTitleName();
28178 wxPyEndAllowThreads(__tstate);
28179 if (PyErr_Occurred()) SWIG_fail;
28180 }
28181 {
28182 #if wxUSE_UNICODE
28183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28184 #else
28185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28186 #endif
28187 }
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28195 PyObject *resultobj = 0;
28196 bool arg1 ;
28197 bool val1 ;
28198 int ecode1 = 0 ;
28199 PyObject * obj0 = 0 ;
28200 char * kwnames[] = {
28201 (char *) "val", NULL
28202 };
28203
28204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28205 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28206 if (!SWIG_IsOK(ecode1)) {
28207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28208 }
28209 arg1 = static_cast< bool >(val1);
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_Py_Void();
28217 return resultobj;
28218 fail:
28219 return NULL;
28220 }
28221
28222
28223 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28224 PyObject *resultobj = 0;
28225 long arg1 ;
28226 long val1 ;
28227 int ecode1 = 0 ;
28228 PyObject * obj0 = 0 ;
28229 char * kwnames[] = {
28230 (char *) "val", NULL
28231 };
28232
28233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28234 ecode1 = SWIG_AsVal_long(obj0, &val1);
28235 if (!SWIG_IsOK(ecode1)) {
28236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28237 }
28238 arg1 = static_cast< long >(val1);
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 wxPyApp::SetMacAboutMenuItemId(arg1);
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 resultobj = SWIG_Py_Void();
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28253 PyObject *resultobj = 0;
28254 long arg1 ;
28255 long val1 ;
28256 int ecode1 = 0 ;
28257 PyObject * obj0 = 0 ;
28258 char * kwnames[] = {
28259 (char *) "val", NULL
28260 };
28261
28262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28263 ecode1 = SWIG_AsVal_long(obj0, &val1);
28264 if (!SWIG_IsOK(ecode1)) {
28265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28266 }
28267 arg1 = static_cast< long >(val1);
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 resultobj = SWIG_Py_Void();
28275 return resultobj;
28276 fail:
28277 return NULL;
28278 }
28279
28280
28281 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28282 PyObject *resultobj = 0;
28283 long arg1 ;
28284 long val1 ;
28285 int ecode1 = 0 ;
28286 PyObject * obj0 = 0 ;
28287 char * kwnames[] = {
28288 (char *) "val", NULL
28289 };
28290
28291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28292 ecode1 = SWIG_AsVal_long(obj0, &val1);
28293 if (!SWIG_IsOK(ecode1)) {
28294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28295 }
28296 arg1 = static_cast< long >(val1);
28297 {
28298 PyThreadState* __tstate = wxPyBeginAllowThreads();
28299 wxPyApp::SetMacExitMenuItemId(arg1);
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 resultobj = SWIG_Py_Void();
28304 return resultobj;
28305 fail:
28306 return NULL;
28307 }
28308
28309
28310 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28311 PyObject *resultobj = 0;
28312 wxString *arg1 = 0 ;
28313 bool temp1 = false ;
28314 PyObject * obj0 = 0 ;
28315 char * kwnames[] = {
28316 (char *) "val", NULL
28317 };
28318
28319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28320 {
28321 arg1 = wxString_in_helper(obj0);
28322 if (arg1 == NULL) SWIG_fail;
28323 temp1 = true;
28324 }
28325 {
28326 PyThreadState* __tstate = wxPyBeginAllowThreads();
28327 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 resultobj = SWIG_Py_Void();
28332 {
28333 if (temp1)
28334 delete arg1;
28335 }
28336 return resultobj;
28337 fail:
28338 {
28339 if (temp1)
28340 delete arg1;
28341 }
28342 return NULL;
28343 }
28344
28345
28346 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28347 PyObject *resultobj = 0;
28348 wxPyApp *arg1 = (wxPyApp *) 0 ;
28349 void *argp1 = 0 ;
28350 int res1 = 0 ;
28351 PyObject *swig_obj[1] ;
28352
28353 if (!args) SWIG_fail;
28354 swig_obj[0] = args;
28355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28356 if (!SWIG_IsOK(res1)) {
28357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28358 }
28359 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 (arg1)->_BootstrapApp();
28363 wxPyEndAllowThreads(__tstate);
28364 if (PyErr_Occurred()) SWIG_fail;
28365 }
28366 resultobj = SWIG_Py_Void();
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28374 PyObject *resultobj = 0;
28375 int result;
28376
28377 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 result = (int)wxPyApp::GetComCtl32Version();
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 resultobj = SWIG_From_int(static_cast< int >(result));
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *obj;
28393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28394 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28395 return SWIG_Py_Void();
28396 }
28397
28398 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28399 return SWIG_Python_InitShadowInstance(args);
28400 }
28401
28402 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28403 PyObject *resultobj = 0;
28404
28405 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 wxExit();
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 resultobj = SWIG_Py_Void();
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28420 PyObject *resultobj = 0;
28421 bool result;
28422
28423 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28424 {
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = (bool)wxYield();
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 {
28431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28432 }
28433 return resultobj;
28434 fail:
28435 return NULL;
28436 }
28437
28438
28439 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28440 PyObject *resultobj = 0;
28441 bool result;
28442
28443 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28444 {
28445 PyThreadState* __tstate = wxPyBeginAllowThreads();
28446 result = (bool)wxYieldIfNeeded();
28447 wxPyEndAllowThreads(__tstate);
28448 if (PyErr_Occurred()) SWIG_fail;
28449 }
28450 {
28451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28452 }
28453 return resultobj;
28454 fail:
28455 return NULL;
28456 }
28457
28458
28459 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28460 PyObject *resultobj = 0;
28461 wxWindow *arg1 = (wxWindow *) NULL ;
28462 bool arg2 = (bool) false ;
28463 bool result;
28464 void *argp1 = 0 ;
28465 int res1 = 0 ;
28466 bool val2 ;
28467 int ecode2 = 0 ;
28468 PyObject * obj0 = 0 ;
28469 PyObject * obj1 = 0 ;
28470 char * kwnames[] = {
28471 (char *) "win",(char *) "onlyIfNeeded", NULL
28472 };
28473
28474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28475 if (obj0) {
28476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28477 if (!SWIG_IsOK(res1)) {
28478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28479 }
28480 arg1 = reinterpret_cast< wxWindow * >(argp1);
28481 }
28482 if (obj1) {
28483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28484 if (!SWIG_IsOK(ecode2)) {
28485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28486 }
28487 arg2 = static_cast< bool >(val2);
28488 }
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (bool)wxSafeYield(arg1,arg2);
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *resultobj = 0;
28506
28507 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 wxWakeUpIdle();
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 resultobj = SWIG_Py_Void();
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj = 0;
28523 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28524 wxEvent *arg2 = 0 ;
28525 void *argp1 = 0 ;
28526 int res1 = 0 ;
28527 void *argp2 = 0 ;
28528 int res2 = 0 ;
28529 PyObject * obj0 = 0 ;
28530 PyObject * obj1 = 0 ;
28531 char * kwnames[] = {
28532 (char *) "dest",(char *) "event", NULL
28533 };
28534
28535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28537 if (!SWIG_IsOK(res1)) {
28538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28539 }
28540 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28541 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28542 if (!SWIG_IsOK(res2)) {
28543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28544 }
28545 if (!argp2) {
28546 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28547 }
28548 arg2 = reinterpret_cast< wxEvent * >(argp2);
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 wxPostEvent(arg1,*arg2);
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 resultobj = SWIG_Py_Void();
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28563 PyObject *resultobj = 0;
28564
28565 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 wxApp_CleanUp();
28569 wxPyEndAllowThreads(__tstate);
28570 if (PyErr_Occurred()) SWIG_fail;
28571 }
28572 resultobj = SWIG_Py_Void();
28573 return resultobj;
28574 fail:
28575 return NULL;
28576 }
28577
28578
28579 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28580 PyObject *resultobj = 0;
28581 wxPyApp *result = 0 ;
28582
28583 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 result = (wxPyApp *)wxPyGetApp();
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 resultobj = wxPyMake_wxObject(result, 0);
28592 }
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28600 PyObject *resultobj = 0;
28601 char *arg1 = (char *) 0 ;
28602 int res1 ;
28603 char *buf1 = 0 ;
28604 int alloc1 = 0 ;
28605 PyObject * obj0 = 0 ;
28606 char * kwnames[] = {
28607 (char *) "encoding", NULL
28608 };
28609
28610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28611 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28612 if (!SWIG_IsOK(res1)) {
28613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28614 }
28615 arg1 = buf1;
28616 {
28617 PyThreadState* __tstate = wxPyBeginAllowThreads();
28618 wxSetDefaultPyEncoding((char const *)arg1);
28619 wxPyEndAllowThreads(__tstate);
28620 if (PyErr_Occurred()) SWIG_fail;
28621 }
28622 resultobj = SWIG_Py_Void();
28623 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28624 return resultobj;
28625 fail:
28626 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *resultobj = 0;
28633 char *result = 0 ;
28634
28635 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (char *)wxGetDefaultPyEncoding();
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 resultobj = SWIG_FromCharPtr(result);
28643 return resultobj;
28644 fail:
28645 return NULL;
28646 }
28647
28648
28649 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 PyObject *resultobj = 0;
28651 wxEventLoop *result = 0 ;
28652
28653 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (wxEventLoop *)new wxEventLoop();
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *resultobj = 0;
28669 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28670 void *argp1 = 0 ;
28671 int res1 = 0 ;
28672 PyObject *swig_obj[1] ;
28673
28674 if (!args) SWIG_fail;
28675 swig_obj[0] = args;
28676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28677 if (!SWIG_IsOK(res1)) {
28678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28679 }
28680 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 delete arg1;
28684
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 resultobj = SWIG_Py_Void();
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28696 PyObject *resultobj = 0;
28697 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28698 int result;
28699 void *argp1 = 0 ;
28700 int res1 = 0 ;
28701 PyObject *swig_obj[1] ;
28702
28703 if (!args) SWIG_fail;
28704 swig_obj[0] = args;
28705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28706 if (!SWIG_IsOK(res1)) {
28707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28708 }
28709 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28710 {
28711 PyThreadState* __tstate = wxPyBeginAllowThreads();
28712 result = (int)(arg1)->Run();
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 resultobj = SWIG_From_int(static_cast< int >(result));
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj = 0;
28725 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28726 int arg2 = (int) 0 ;
28727 void *argp1 = 0 ;
28728 int res1 = 0 ;
28729 int val2 ;
28730 int ecode2 = 0 ;
28731 PyObject * obj0 = 0 ;
28732 PyObject * obj1 = 0 ;
28733 char * kwnames[] = {
28734 (char *) "self",(char *) "rc", NULL
28735 };
28736
28737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28741 }
28742 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28743 if (obj1) {
28744 ecode2 = SWIG_AsVal_int(obj1, &val2);
28745 if (!SWIG_IsOK(ecode2)) {
28746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28747 }
28748 arg2 = static_cast< int >(val2);
28749 }
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 (arg1)->Exit(arg2);
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 resultobj = SWIG_Py_Void();
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28764 PyObject *resultobj = 0;
28765 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28766 bool result;
28767 void *argp1 = 0 ;
28768 int res1 = 0 ;
28769 PyObject *swig_obj[1] ;
28770
28771 if (!args) SWIG_fail;
28772 swig_obj[0] = args;
28773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28774 if (!SWIG_IsOK(res1)) {
28775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28776 }
28777 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (bool)((wxEventLoop const *)arg1)->Pending();
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 {
28785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28786 }
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28794 PyObject *resultobj = 0;
28795 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28796 bool result;
28797 void *argp1 = 0 ;
28798 int res1 = 0 ;
28799 PyObject *swig_obj[1] ;
28800
28801 if (!args) SWIG_fail;
28802 swig_obj[0] = args;
28803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28804 if (!SWIG_IsOK(res1)) {
28805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28806 }
28807 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 result = (bool)(arg1)->Dispatch();
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 {
28815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28816 }
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28826 bool result;
28827 void *argp1 = 0 ;
28828 int res1 = 0 ;
28829 PyObject *swig_obj[1] ;
28830
28831 if (!args) SWIG_fail;
28832 swig_obj[0] = args;
28833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28834 if (!SWIG_IsOK(res1)) {
28835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28836 }
28837 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 {
28845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28846 }
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28854 PyObject *resultobj = 0;
28855 wxEventLoop *result = 0 ;
28856
28857 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28858 {
28859 PyThreadState* __tstate = wxPyBeginAllowThreads();
28860 result = (wxEventLoop *)wxEventLoop::GetActive();
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj = 0;
28873 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28874 void *argp1 = 0 ;
28875 int res1 = 0 ;
28876 PyObject * obj0 = 0 ;
28877 char * kwnames[] = {
28878 (char *) "loop", NULL
28879 };
28880
28881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28883 if (!SWIG_IsOK(res1)) {
28884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28885 }
28886 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28887 {
28888 PyThreadState* __tstate = wxPyBeginAllowThreads();
28889 wxEventLoop::SetActive(arg1);
28890 wxPyEndAllowThreads(__tstate);
28891 if (PyErr_Occurred()) SWIG_fail;
28892 }
28893 resultobj = SWIG_Py_Void();
28894 return resultobj;
28895 fail:
28896 return NULL;
28897 }
28898
28899
28900 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28901 PyObject *obj;
28902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28903 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28904 return SWIG_Py_Void();
28905 }
28906
28907 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28908 return SWIG_Python_InitShadowInstance(args);
28909 }
28910
28911 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28912 PyObject *resultobj = 0;
28913 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28914 wxEventLoopActivator *result = 0 ;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject * obj0 = 0 ;
28918 char * kwnames[] = {
28919 (char *) "evtLoop", NULL
28920 };
28921
28922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28924 if (!SWIG_IsOK(res1)) {
28925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28926 }
28927 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28935 return resultobj;
28936 fail:
28937 return NULL;
28938 }
28939
28940
28941 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28942 PyObject *resultobj = 0;
28943 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28944 void *argp1 = 0 ;
28945 int res1 = 0 ;
28946 PyObject *swig_obj[1] ;
28947
28948 if (!args) SWIG_fail;
28949 swig_obj[0] = args;
28950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28951 if (!SWIG_IsOK(res1)) {
28952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28953 }
28954 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 delete arg1;
28958
28959 wxPyEndAllowThreads(__tstate);
28960 if (PyErr_Occurred()) SWIG_fail;
28961 }
28962 resultobj = SWIG_Py_Void();
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28970 PyObject *obj;
28971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28972 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28973 return SWIG_Py_Void();
28974 }
28975
28976 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28977 return SWIG_Python_InitShadowInstance(args);
28978 }
28979
28980 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj = 0;
28982 int arg1 = (int) 0 ;
28983 int arg2 = (int) 0 ;
28984 int arg3 = (int) 0 ;
28985 wxAcceleratorEntry *result = 0 ;
28986 int val1 ;
28987 int ecode1 = 0 ;
28988 int val2 ;
28989 int ecode2 = 0 ;
28990 int val3 ;
28991 int ecode3 = 0 ;
28992 PyObject * obj0 = 0 ;
28993 PyObject * obj1 = 0 ;
28994 PyObject * obj2 = 0 ;
28995 char * kwnames[] = {
28996 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28997 };
28998
28999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29000 if (obj0) {
29001 ecode1 = SWIG_AsVal_int(obj0, &val1);
29002 if (!SWIG_IsOK(ecode1)) {
29003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29004 }
29005 arg1 = static_cast< int >(val1);
29006 }
29007 if (obj1) {
29008 ecode2 = SWIG_AsVal_int(obj1, &val2);
29009 if (!SWIG_IsOK(ecode2)) {
29010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29011 }
29012 arg2 = static_cast< int >(val2);
29013 }
29014 if (obj2) {
29015 ecode3 = SWIG_AsVal_int(obj2, &val3);
29016 if (!SWIG_IsOK(ecode3)) {
29017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29018 }
29019 arg3 = static_cast< int >(val3);
29020 }
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29035 PyObject *resultobj = 0;
29036 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29037 void *argp1 = 0 ;
29038 int res1 = 0 ;
29039 PyObject *swig_obj[1] ;
29040
29041 if (!args) SWIG_fail;
29042 swig_obj[0] = args;
29043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29044 if (!SWIG_IsOK(res1)) {
29045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29046 }
29047 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29048 {
29049 PyThreadState* __tstate = wxPyBeginAllowThreads();
29050 delete arg1;
29051
29052 wxPyEndAllowThreads(__tstate);
29053 if (PyErr_Occurred()) SWIG_fail;
29054 }
29055 resultobj = SWIG_Py_Void();
29056 return resultobj;
29057 fail:
29058 return NULL;
29059 }
29060
29061
29062 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj = 0;
29064 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29065 int arg2 ;
29066 int arg3 ;
29067 int arg4 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 int val2 ;
29071 int ecode2 = 0 ;
29072 int val3 ;
29073 int ecode3 = 0 ;
29074 int val4 ;
29075 int ecode4 = 0 ;
29076 PyObject * obj0 = 0 ;
29077 PyObject * obj1 = 0 ;
29078 PyObject * obj2 = 0 ;
29079 PyObject * obj3 = 0 ;
29080 char * kwnames[] = {
29081 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29082 };
29083
29084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29086 if (!SWIG_IsOK(res1)) {
29087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29088 }
29089 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29090 ecode2 = SWIG_AsVal_int(obj1, &val2);
29091 if (!SWIG_IsOK(ecode2)) {
29092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29093 }
29094 arg2 = static_cast< int >(val2);
29095 ecode3 = SWIG_AsVal_int(obj2, &val3);
29096 if (!SWIG_IsOK(ecode3)) {
29097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29098 }
29099 arg3 = static_cast< int >(val3);
29100 ecode4 = SWIG_AsVal_int(obj3, &val4);
29101 if (!SWIG_IsOK(ecode4)) {
29102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29103 }
29104 arg4 = static_cast< int >(val4);
29105 {
29106 PyThreadState* __tstate = wxPyBeginAllowThreads();
29107 (arg1)->Set(arg2,arg3,arg4);
29108 wxPyEndAllowThreads(__tstate);
29109 if (PyErr_Occurred()) SWIG_fail;
29110 }
29111 resultobj = SWIG_Py_Void();
29112 return resultobj;
29113 fail:
29114 return NULL;
29115 }
29116
29117
29118 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29119 PyObject *resultobj = 0;
29120 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29121 int result;
29122 void *argp1 = 0 ;
29123 int res1 = 0 ;
29124 PyObject *swig_obj[1] ;
29125
29126 if (!args) SWIG_fail;
29127 swig_obj[0] = args;
29128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29129 if (!SWIG_IsOK(res1)) {
29130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29131 }
29132 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29133 {
29134 PyThreadState* __tstate = wxPyBeginAllowThreads();
29135 result = (int)(arg1)->GetFlags();
29136 wxPyEndAllowThreads(__tstate);
29137 if (PyErr_Occurred()) SWIG_fail;
29138 }
29139 resultobj = SWIG_From_int(static_cast< int >(result));
29140 return resultobj;
29141 fail:
29142 return NULL;
29143 }
29144
29145
29146 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29147 PyObject *resultobj = 0;
29148 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29149 int result;
29150 void *argp1 = 0 ;
29151 int res1 = 0 ;
29152 PyObject *swig_obj[1] ;
29153
29154 if (!args) SWIG_fail;
29155 swig_obj[0] = args;
29156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29157 if (!SWIG_IsOK(res1)) {
29158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29159 }
29160 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = (int)(arg1)->GetKeyCode();
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 resultobj = SWIG_From_int(static_cast< int >(result));
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29175 PyObject *resultobj = 0;
29176 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29177 int result;
29178 void *argp1 = 0 ;
29179 int res1 = 0 ;
29180 PyObject *swig_obj[1] ;
29181
29182 if (!args) SWIG_fail;
29183 swig_obj[0] = args;
29184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29185 if (!SWIG_IsOK(res1)) {
29186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29187 }
29188 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = (int)(arg1)->GetCommand();
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_From_int(static_cast< int >(result));
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29203 PyObject *obj;
29204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29205 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29206 return SWIG_Py_Void();
29207 }
29208
29209 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 return SWIG_Python_InitShadowInstance(args);
29211 }
29212
29213 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29214 PyObject *resultobj = 0;
29215 int arg1 ;
29216 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29217 wxAcceleratorTable *result = 0 ;
29218 PyObject * obj0 = 0 ;
29219 char * kwnames[] = {
29220 (char *) "n", NULL
29221 };
29222
29223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29224 {
29225 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29226 if (arg2) arg1 = PyList_Size(obj0);
29227 else arg1 = 0;
29228 }
29229 {
29230 PyThreadState* __tstate = wxPyBeginAllowThreads();
29231 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29232 wxPyEndAllowThreads(__tstate);
29233 if (PyErr_Occurred()) SWIG_fail;
29234 }
29235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29236 return resultobj;
29237 fail:
29238 return NULL;
29239 }
29240
29241
29242 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29245 void *argp1 = 0 ;
29246 int res1 = 0 ;
29247 PyObject *swig_obj[1] ;
29248
29249 if (!args) SWIG_fail;
29250 swig_obj[0] = args;
29251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29252 if (!SWIG_IsOK(res1)) {
29253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29254 }
29255 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 delete arg1;
29259
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 resultobj = SWIG_Py_Void();
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29271 PyObject *resultobj = 0;
29272 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29273 bool result;
29274 void *argp1 = 0 ;
29275 int res1 = 0 ;
29276 PyObject *swig_obj[1] ;
29277
29278 if (!args) SWIG_fail;
29279 swig_obj[0] = args;
29280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29281 if (!SWIG_IsOK(res1)) {
29282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29283 }
29284 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 {
29292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29293 }
29294 return resultobj;
29295 fail:
29296 return NULL;
29297 }
29298
29299
29300 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29301 PyObject *obj;
29302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29303 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29304 return SWIG_Py_Void();
29305 }
29306
29307 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29308 return SWIG_Python_InitShadowInstance(args);
29309 }
29310
29311 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29312 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29313 return 1;
29314 }
29315
29316
29317 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29318 PyObject *pyobj = 0;
29319
29320 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29321 return pyobj;
29322 }
29323
29324
29325 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29326 PyObject *resultobj = 0;
29327 wxString *arg1 = 0 ;
29328 wxAcceleratorEntry *result = 0 ;
29329 bool temp1 = false ;
29330 PyObject * obj0 = 0 ;
29331 char * kwnames[] = {
29332 (char *) "label", NULL
29333 };
29334
29335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29336 {
29337 arg1 = wxString_in_helper(obj0);
29338 if (arg1 == NULL) SWIG_fail;
29339 temp1 = true;
29340 }
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29348 {
29349 if (temp1)
29350 delete arg1;
29351 }
29352 return resultobj;
29353 fail:
29354 {
29355 if (temp1)
29356 delete arg1;
29357 }
29358 return NULL;
29359 }
29360
29361
29362 SWIGINTERN int PanelNameStr_set(PyObject *) {
29363 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29364 return 1;
29365 }
29366
29367
29368 SWIGINTERN PyObject *PanelNameStr_get(void) {
29369 PyObject *pyobj = 0;
29370
29371 {
29372 #if wxUSE_UNICODE
29373 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29374 #else
29375 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29376 #endif
29377 }
29378 return pyobj;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29383 PyObject *resultobj = 0;
29384 wxVisualAttributes *result = 0 ;
29385
29386 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 result = (wxVisualAttributes *)new_wxVisualAttributes();
29390 wxPyEndAllowThreads(__tstate);
29391 if (PyErr_Occurred()) SWIG_fail;
29392 }
29393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29403 void *argp1 = 0 ;
29404 int res1 = 0 ;
29405 PyObject *swig_obj[1] ;
29406
29407 if (!args) SWIG_fail;
29408 swig_obj[0] = args;
29409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29412 }
29413 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 delete_wxVisualAttributes(arg1);
29417
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 resultobj = SWIG_Py_Void();
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29429 PyObject *resultobj = 0;
29430 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29431 wxFont *arg2 = (wxFont *) 0 ;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 void *argp2 = 0 ;
29435 int res2 = 0 ;
29436 PyObject *swig_obj[2] ;
29437
29438 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29440 if (!SWIG_IsOK(res1)) {
29441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29442 }
29443 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29444 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29445 if (!SWIG_IsOK(res2)) {
29446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29447 }
29448 arg2 = reinterpret_cast< wxFont * >(argp2);
29449 if (arg1) (arg1)->font = *arg2;
29450
29451 resultobj = SWIG_Py_Void();
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29461 wxFont *result = 0 ;
29462 void *argp1 = 0 ;
29463 int res1 = 0 ;
29464 PyObject *swig_obj[1] ;
29465
29466 if (!args) SWIG_fail;
29467 swig_obj[0] = args;
29468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29469 if (!SWIG_IsOK(res1)) {
29470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29471 }
29472 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29473 result = (wxFont *)& ((arg1)->font);
29474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29475 return resultobj;
29476 fail:
29477 return NULL;
29478 }
29479
29480
29481 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29482 PyObject *resultobj = 0;
29483 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29484 wxColour *arg2 = (wxColour *) 0 ;
29485 void *argp1 = 0 ;
29486 int res1 = 0 ;
29487 void *argp2 = 0 ;
29488 int res2 = 0 ;
29489 PyObject *swig_obj[2] ;
29490
29491 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29493 if (!SWIG_IsOK(res1)) {
29494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29495 }
29496 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29497 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29498 if (!SWIG_IsOK(res2)) {
29499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29500 }
29501 arg2 = reinterpret_cast< wxColour * >(argp2);
29502 if (arg1) (arg1)->colFg = *arg2;
29503
29504 resultobj = SWIG_Py_Void();
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29512 PyObject *resultobj = 0;
29513 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29514 wxColour *result = 0 ;
29515 void *argp1 = 0 ;
29516 int res1 = 0 ;
29517 PyObject *swig_obj[1] ;
29518
29519 if (!args) SWIG_fail;
29520 swig_obj[0] = args;
29521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29522 if (!SWIG_IsOK(res1)) {
29523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29524 }
29525 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29526 result = (wxColour *)& ((arg1)->colFg);
29527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29528 return resultobj;
29529 fail:
29530 return NULL;
29531 }
29532
29533
29534 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29535 PyObject *resultobj = 0;
29536 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29537 wxColour *arg2 = (wxColour *) 0 ;
29538 void *argp1 = 0 ;
29539 int res1 = 0 ;
29540 void *argp2 = 0 ;
29541 int res2 = 0 ;
29542 PyObject *swig_obj[2] ;
29543
29544 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29546 if (!SWIG_IsOK(res1)) {
29547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29548 }
29549 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29550 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29551 if (!SWIG_IsOK(res2)) {
29552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29553 }
29554 arg2 = reinterpret_cast< wxColour * >(argp2);
29555 if (arg1) (arg1)->colBg = *arg2;
29556
29557 resultobj = SWIG_Py_Void();
29558 return resultobj;
29559 fail:
29560 return NULL;
29561 }
29562
29563
29564 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29565 PyObject *resultobj = 0;
29566 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29567 wxColour *result = 0 ;
29568 void *argp1 = 0 ;
29569 int res1 = 0 ;
29570 PyObject *swig_obj[1] ;
29571
29572 if (!args) SWIG_fail;
29573 swig_obj[0] = args;
29574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29575 if (!SWIG_IsOK(res1)) {
29576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29577 }
29578 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29579 result = (wxColour *)& ((arg1)->colBg);
29580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29588 PyObject *obj;
29589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29590 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29591 return SWIG_Py_Void();
29592 }
29593
29594 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29595 return SWIG_Python_InitShadowInstance(args);
29596 }
29597
29598 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29599 PyObject *resultobj = 0;
29600 wxWindow *arg1 = (wxWindow *) 0 ;
29601 int arg2 = (int) (int)-1 ;
29602 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29603 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29604 wxSize const &arg4_defvalue = wxDefaultSize ;
29605 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29606 long arg5 = (long) 0 ;
29607 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29608 wxString *arg6 = (wxString *) &arg6_defvalue ;
29609 wxWindow *result = 0 ;
29610 void *argp1 = 0 ;
29611 int res1 = 0 ;
29612 int val2 ;
29613 int ecode2 = 0 ;
29614 wxPoint temp3 ;
29615 wxSize temp4 ;
29616 long val5 ;
29617 int ecode5 = 0 ;
29618 bool temp6 = false ;
29619 PyObject * obj0 = 0 ;
29620 PyObject * obj1 = 0 ;
29621 PyObject * obj2 = 0 ;
29622 PyObject * obj3 = 0 ;
29623 PyObject * obj4 = 0 ;
29624 PyObject * obj5 = 0 ;
29625 char * kwnames[] = {
29626 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29627 };
29628
29629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29631 if (!SWIG_IsOK(res1)) {
29632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29633 }
29634 arg1 = reinterpret_cast< wxWindow * >(argp1);
29635 if (obj1) {
29636 ecode2 = SWIG_AsVal_int(obj1, &val2);
29637 if (!SWIG_IsOK(ecode2)) {
29638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29639 }
29640 arg2 = static_cast< int >(val2);
29641 }
29642 if (obj2) {
29643 {
29644 arg3 = &temp3;
29645 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29646 }
29647 }
29648 if (obj3) {
29649 {
29650 arg4 = &temp4;
29651 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29652 }
29653 }
29654 if (obj4) {
29655 ecode5 = SWIG_AsVal_long(obj4, &val5);
29656 if (!SWIG_IsOK(ecode5)) {
29657 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29658 }
29659 arg5 = static_cast< long >(val5);
29660 }
29661 if (obj5) {
29662 {
29663 arg6 = wxString_in_helper(obj5);
29664 if (arg6 == NULL) SWIG_fail;
29665 temp6 = true;
29666 }
29667 }
29668 {
29669 if (!wxPyCheckForApp()) SWIG_fail;
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29676 {
29677 if (temp6)
29678 delete arg6;
29679 }
29680 return resultobj;
29681 fail:
29682 {
29683 if (temp6)
29684 delete arg6;
29685 }
29686 return NULL;
29687 }
29688
29689
29690 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29691 PyObject *resultobj = 0;
29692 wxWindow *result = 0 ;
29693
29694 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29695 {
29696 if (!wxPyCheckForApp()) SWIG_fail;
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 result = (wxWindow *)new wxWindow();
29699 wxPyEndAllowThreads(__tstate);
29700 if (PyErr_Occurred()) SWIG_fail;
29701 }
29702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj = 0;
29711 wxWindow *arg1 = (wxWindow *) 0 ;
29712 wxWindow *arg2 = (wxWindow *) 0 ;
29713 int arg3 = (int) (int)-1 ;
29714 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29715 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29716 wxSize const &arg5_defvalue = wxDefaultSize ;
29717 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29718 long arg6 = (long) 0 ;
29719 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29720 wxString *arg7 = (wxString *) &arg7_defvalue ;
29721 bool result;
29722 void *argp1 = 0 ;
29723 int res1 = 0 ;
29724 void *argp2 = 0 ;
29725 int res2 = 0 ;
29726 int val3 ;
29727 int ecode3 = 0 ;
29728 wxPoint temp4 ;
29729 wxSize temp5 ;
29730 long val6 ;
29731 int ecode6 = 0 ;
29732 bool temp7 = false ;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 PyObject * obj2 = 0 ;
29736 PyObject * obj3 = 0 ;
29737 PyObject * obj4 = 0 ;
29738 PyObject * obj5 = 0 ;
29739 PyObject * obj6 = 0 ;
29740 char * kwnames[] = {
29741 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29742 };
29743
29744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29746 if (!SWIG_IsOK(res1)) {
29747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29748 }
29749 arg1 = reinterpret_cast< wxWindow * >(argp1);
29750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29751 if (!SWIG_IsOK(res2)) {
29752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29753 }
29754 arg2 = reinterpret_cast< wxWindow * >(argp2);
29755 if (obj2) {
29756 ecode3 = SWIG_AsVal_int(obj2, &val3);
29757 if (!SWIG_IsOK(ecode3)) {
29758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29759 }
29760 arg3 = static_cast< int >(val3);
29761 }
29762 if (obj3) {
29763 {
29764 arg4 = &temp4;
29765 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29766 }
29767 }
29768 if (obj4) {
29769 {
29770 arg5 = &temp5;
29771 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29772 }
29773 }
29774 if (obj5) {
29775 ecode6 = SWIG_AsVal_long(obj5, &val6);
29776 if (!SWIG_IsOK(ecode6)) {
29777 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29778 }
29779 arg6 = static_cast< long >(val6);
29780 }
29781 if (obj6) {
29782 {
29783 arg7 = wxString_in_helper(obj6);
29784 if (arg7 == NULL) SWIG_fail;
29785 temp7 = true;
29786 }
29787 }
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 {
29795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29796 }
29797 {
29798 if (temp7)
29799 delete arg7;
29800 }
29801 return resultobj;
29802 fail:
29803 {
29804 if (temp7)
29805 delete arg7;
29806 }
29807 return NULL;
29808 }
29809
29810
29811 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29812 PyObject *resultobj = 0;
29813 wxWindow *arg1 = (wxWindow *) 0 ;
29814 bool arg2 = (bool) false ;
29815 bool result;
29816 void *argp1 = 0 ;
29817 int res1 = 0 ;
29818 bool val2 ;
29819 int ecode2 = 0 ;
29820 PyObject * obj0 = 0 ;
29821 PyObject * obj1 = 0 ;
29822 char * kwnames[] = {
29823 (char *) "self",(char *) "force", NULL
29824 };
29825
29826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29828 if (!SWIG_IsOK(res1)) {
29829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29830 }
29831 arg1 = reinterpret_cast< wxWindow * >(argp1);
29832 if (obj1) {
29833 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29834 if (!SWIG_IsOK(ecode2)) {
29835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29836 }
29837 arg2 = static_cast< bool >(val2);
29838 }
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 result = (bool)(arg1)->Close(arg2);
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 {
29846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29847 }
29848 return resultobj;
29849 fail:
29850 return NULL;
29851 }
29852
29853
29854 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29855 PyObject *resultobj = 0;
29856 wxWindow *arg1 = (wxWindow *) 0 ;
29857 bool result;
29858 void *argp1 = 0 ;
29859 int res1 = 0 ;
29860 PyObject *swig_obj[1] ;
29861
29862 if (!args) SWIG_fail;
29863 swig_obj[0] = args;
29864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29865 if (!SWIG_IsOK(res1)) {
29866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29867 }
29868 arg1 = reinterpret_cast< wxWindow * >(argp1);
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 result = (bool)(arg1)->Destroy();
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 {
29876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29877 }
29878 return resultobj;
29879 fail:
29880 return NULL;
29881 }
29882
29883
29884 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29885 PyObject *resultobj = 0;
29886 wxWindow *arg1 = (wxWindow *) 0 ;
29887 bool result;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 PyObject *swig_obj[1] ;
29891
29892 if (!args) SWIG_fail;
29893 swig_obj[0] = args;
29894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29895 if (!SWIG_IsOK(res1)) {
29896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29897 }
29898 arg1 = reinterpret_cast< wxWindow * >(argp1);
29899 {
29900 PyThreadState* __tstate = wxPyBeginAllowThreads();
29901 result = (bool)(arg1)->DestroyChildren();
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 {
29906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29907 }
29908 return resultobj;
29909 fail:
29910 return NULL;
29911 }
29912
29913
29914 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29915 PyObject *resultobj = 0;
29916 wxWindow *arg1 = (wxWindow *) 0 ;
29917 bool result;
29918 void *argp1 = 0 ;
29919 int res1 = 0 ;
29920 PyObject *swig_obj[1] ;
29921
29922 if (!args) SWIG_fail;
29923 swig_obj[0] = args;
29924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29925 if (!SWIG_IsOK(res1)) {
29926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29927 }
29928 arg1 = reinterpret_cast< wxWindow * >(argp1);
29929 {
29930 PyThreadState* __tstate = wxPyBeginAllowThreads();
29931 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29932 wxPyEndAllowThreads(__tstate);
29933 if (PyErr_Occurred()) SWIG_fail;
29934 }
29935 {
29936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29937 }
29938 return resultobj;
29939 fail:
29940 return NULL;
29941 }
29942
29943
29944 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29945 PyObject *resultobj = 0;
29946 wxWindow *arg1 = (wxWindow *) 0 ;
29947 wxString *arg2 = 0 ;
29948 void *argp1 = 0 ;
29949 int res1 = 0 ;
29950 bool temp2 = false ;
29951 PyObject * obj0 = 0 ;
29952 PyObject * obj1 = 0 ;
29953 char * kwnames[] = {
29954 (char *) "self",(char *) "label", NULL
29955 };
29956
29957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29959 if (!SWIG_IsOK(res1)) {
29960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29961 }
29962 arg1 = reinterpret_cast< wxWindow * >(argp1);
29963 {
29964 arg2 = wxString_in_helper(obj1);
29965 if (arg2 == NULL) SWIG_fail;
29966 temp2 = true;
29967 }
29968 {
29969 PyThreadState* __tstate = wxPyBeginAllowThreads();
29970 (arg1)->SetLabel((wxString const &)*arg2);
29971 wxPyEndAllowThreads(__tstate);
29972 if (PyErr_Occurred()) SWIG_fail;
29973 }
29974 resultobj = SWIG_Py_Void();
29975 {
29976 if (temp2)
29977 delete arg2;
29978 }
29979 return resultobj;
29980 fail:
29981 {
29982 if (temp2)
29983 delete arg2;
29984 }
29985 return NULL;
29986 }
29987
29988
29989 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29990 PyObject *resultobj = 0;
29991 wxWindow *arg1 = (wxWindow *) 0 ;
29992 wxString result;
29993 void *argp1 = 0 ;
29994 int res1 = 0 ;
29995 PyObject *swig_obj[1] ;
29996
29997 if (!args) SWIG_fail;
29998 swig_obj[0] = args;
29999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30000 if (!SWIG_IsOK(res1)) {
30001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30002 }
30003 arg1 = reinterpret_cast< wxWindow * >(argp1);
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 result = ((wxWindow const *)arg1)->GetLabel();
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 {
30011 #if wxUSE_UNICODE
30012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30013 #else
30014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30015 #endif
30016 }
30017 return resultobj;
30018 fail:
30019 return NULL;
30020 }
30021
30022
30023 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30024 PyObject *resultobj = 0;
30025 wxWindow *arg1 = (wxWindow *) 0 ;
30026 wxString *arg2 = 0 ;
30027 void *argp1 = 0 ;
30028 int res1 = 0 ;
30029 bool temp2 = false ;
30030 PyObject * obj0 = 0 ;
30031 PyObject * obj1 = 0 ;
30032 char * kwnames[] = {
30033 (char *) "self",(char *) "name", NULL
30034 };
30035
30036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30038 if (!SWIG_IsOK(res1)) {
30039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30040 }
30041 arg1 = reinterpret_cast< wxWindow * >(argp1);
30042 {
30043 arg2 = wxString_in_helper(obj1);
30044 if (arg2 == NULL) SWIG_fail;
30045 temp2 = true;
30046 }
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 (arg1)->SetName((wxString const &)*arg2);
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 resultobj = SWIG_Py_Void();
30054 {
30055 if (temp2)
30056 delete arg2;
30057 }
30058 return resultobj;
30059 fail:
30060 {
30061 if (temp2)
30062 delete arg2;
30063 }
30064 return NULL;
30065 }
30066
30067
30068 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30069 PyObject *resultobj = 0;
30070 wxWindow *arg1 = (wxWindow *) 0 ;
30071 wxString result;
30072 void *argp1 = 0 ;
30073 int res1 = 0 ;
30074 PyObject *swig_obj[1] ;
30075
30076 if (!args) SWIG_fail;
30077 swig_obj[0] = args;
30078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30079 if (!SWIG_IsOK(res1)) {
30080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30081 }
30082 arg1 = reinterpret_cast< wxWindow * >(argp1);
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 result = ((wxWindow const *)arg1)->GetName();
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 {
30090 #if wxUSE_UNICODE
30091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30092 #else
30093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30094 #endif
30095 }
30096 return resultobj;
30097 fail:
30098 return NULL;
30099 }
30100
30101
30102 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30103 PyObject *resultobj = 0;
30104 wxWindow *arg1 = (wxWindow *) 0 ;
30105 wxWindowVariant arg2 ;
30106 void *argp1 = 0 ;
30107 int res1 = 0 ;
30108 int val2 ;
30109 int ecode2 = 0 ;
30110 PyObject * obj0 = 0 ;
30111 PyObject * obj1 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "self",(char *) "variant", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30120 }
30121 arg1 = reinterpret_cast< wxWindow * >(argp1);
30122 ecode2 = SWIG_AsVal_int(obj1, &val2);
30123 if (!SWIG_IsOK(ecode2)) {
30124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30125 }
30126 arg2 = static_cast< wxWindowVariant >(val2);
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 (arg1)->SetWindowVariant(arg2);
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 resultobj = SWIG_Py_Void();
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30141 PyObject *resultobj = 0;
30142 wxWindow *arg1 = (wxWindow *) 0 ;
30143 wxWindowVariant result;
30144 void *argp1 = 0 ;
30145 int res1 = 0 ;
30146 PyObject *swig_obj[1] ;
30147
30148 if (!args) SWIG_fail;
30149 swig_obj[0] = args;
30150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30151 if (!SWIG_IsOK(res1)) {
30152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30153 }
30154 arg1 = reinterpret_cast< wxWindow * >(argp1);
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_From_int(static_cast< int >(result));
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30169 PyObject *resultobj = 0;
30170 wxWindow *arg1 = (wxWindow *) 0 ;
30171 int arg2 ;
30172 void *argp1 = 0 ;
30173 int res1 = 0 ;
30174 int val2 ;
30175 int ecode2 = 0 ;
30176 PyObject * obj0 = 0 ;
30177 PyObject * obj1 = 0 ;
30178 char * kwnames[] = {
30179 (char *) "self",(char *) "winid", NULL
30180 };
30181
30182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30184 if (!SWIG_IsOK(res1)) {
30185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30186 }
30187 arg1 = reinterpret_cast< wxWindow * >(argp1);
30188 ecode2 = SWIG_AsVal_int(obj1, &val2);
30189 if (!SWIG_IsOK(ecode2)) {
30190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30191 }
30192 arg2 = static_cast< int >(val2);
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 (arg1)->SetId(arg2);
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 resultobj = SWIG_Py_Void();
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30207 PyObject *resultobj = 0;
30208 wxWindow *arg1 = (wxWindow *) 0 ;
30209 int result;
30210 void *argp1 = 0 ;
30211 int res1 = 0 ;
30212 PyObject *swig_obj[1] ;
30213
30214 if (!args) SWIG_fail;
30215 swig_obj[0] = args;
30216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30217 if (!SWIG_IsOK(res1)) {
30218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30219 }
30220 arg1 = reinterpret_cast< wxWindow * >(argp1);
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 result = (int)((wxWindow const *)arg1)->GetId();
30224 wxPyEndAllowThreads(__tstate);
30225 if (PyErr_Occurred()) SWIG_fail;
30226 }
30227 resultobj = SWIG_From_int(static_cast< int >(result));
30228 return resultobj;
30229 fail:
30230 return NULL;
30231 }
30232
30233
30234 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30235 PyObject *resultobj = 0;
30236 int result;
30237
30238 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = (int)wxWindow::NewControlId();
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 resultobj = SWIG_From_int(static_cast< int >(result));
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30253 PyObject *resultobj = 0;
30254 int arg1 ;
30255 int result;
30256 int val1 ;
30257 int ecode1 = 0 ;
30258 PyObject * obj0 = 0 ;
30259 char * kwnames[] = {
30260 (char *) "winid", NULL
30261 };
30262
30263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30264 ecode1 = SWIG_AsVal_int(obj0, &val1);
30265 if (!SWIG_IsOK(ecode1)) {
30266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30267 }
30268 arg1 = static_cast< int >(val1);
30269 {
30270 PyThreadState* __tstate = wxPyBeginAllowThreads();
30271 result = (int)wxWindow::NextControlId(arg1);
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 resultobj = SWIG_From_int(static_cast< int >(result));
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30283 PyObject *resultobj = 0;
30284 int arg1 ;
30285 int result;
30286 int val1 ;
30287 int ecode1 = 0 ;
30288 PyObject * obj0 = 0 ;
30289 char * kwnames[] = {
30290 (char *) "winid", NULL
30291 };
30292
30293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30294 ecode1 = SWIG_AsVal_int(obj0, &val1);
30295 if (!SWIG_IsOK(ecode1)) {
30296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30297 }
30298 arg1 = static_cast< int >(val1);
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 result = (int)wxWindow::PrevControlId(arg1);
30302 wxPyEndAllowThreads(__tstate);
30303 if (PyErr_Occurred()) SWIG_fail;
30304 }
30305 resultobj = SWIG_From_int(static_cast< int >(result));
30306 return resultobj;
30307 fail:
30308 return NULL;
30309 }
30310
30311
30312 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30313 PyObject *resultobj = 0;
30314 wxWindow *arg1 = (wxWindow *) 0 ;
30315 wxSize *arg2 = 0 ;
30316 void *argp1 = 0 ;
30317 int res1 = 0 ;
30318 wxSize temp2 ;
30319 PyObject * obj0 = 0 ;
30320 PyObject * obj1 = 0 ;
30321 char * kwnames[] = {
30322 (char *) "self",(char *) "size", NULL
30323 };
30324
30325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30327 if (!SWIG_IsOK(res1)) {
30328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30329 }
30330 arg1 = reinterpret_cast< wxWindow * >(argp1);
30331 {
30332 arg2 = &temp2;
30333 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30334 }
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 (arg1)->SetSize((wxSize const &)*arg2);
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 resultobj = SWIG_Py_Void();
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = 0;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 int arg2 ;
30352 int arg3 ;
30353 int arg4 ;
30354 int arg5 ;
30355 int arg6 = (int) wxSIZE_AUTO ;
30356 void *argp1 = 0 ;
30357 int res1 = 0 ;
30358 int val2 ;
30359 int ecode2 = 0 ;
30360 int val3 ;
30361 int ecode3 = 0 ;
30362 int val4 ;
30363 int ecode4 = 0 ;
30364 int val5 ;
30365 int ecode5 = 0 ;
30366 int val6 ;
30367 int ecode6 = 0 ;
30368 PyObject * obj0 = 0 ;
30369 PyObject * obj1 = 0 ;
30370 PyObject * obj2 = 0 ;
30371 PyObject * obj3 = 0 ;
30372 PyObject * obj4 = 0 ;
30373 PyObject * obj5 = 0 ;
30374 char * kwnames[] = {
30375 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30376 };
30377
30378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30380 if (!SWIG_IsOK(res1)) {
30381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30382 }
30383 arg1 = reinterpret_cast< wxWindow * >(argp1);
30384 ecode2 = SWIG_AsVal_int(obj1, &val2);
30385 if (!SWIG_IsOK(ecode2)) {
30386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30387 }
30388 arg2 = static_cast< int >(val2);
30389 ecode3 = SWIG_AsVal_int(obj2, &val3);
30390 if (!SWIG_IsOK(ecode3)) {
30391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30392 }
30393 arg3 = static_cast< int >(val3);
30394 ecode4 = SWIG_AsVal_int(obj3, &val4);
30395 if (!SWIG_IsOK(ecode4)) {
30396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30397 }
30398 arg4 = static_cast< int >(val4);
30399 ecode5 = SWIG_AsVal_int(obj4, &val5);
30400 if (!SWIG_IsOK(ecode5)) {
30401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30402 }
30403 arg5 = static_cast< int >(val5);
30404 if (obj5) {
30405 ecode6 = SWIG_AsVal_int(obj5, &val6);
30406 if (!SWIG_IsOK(ecode6)) {
30407 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30408 }
30409 arg6 = static_cast< int >(val6);
30410 }
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_Py_Void();
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj = 0;
30426 wxWindow *arg1 = (wxWindow *) 0 ;
30427 wxRect *arg2 = 0 ;
30428 int arg3 = (int) wxSIZE_AUTO ;
30429 void *argp1 = 0 ;
30430 int res1 = 0 ;
30431 wxRect temp2 ;
30432 int val3 ;
30433 int ecode3 = 0 ;
30434 PyObject * obj0 = 0 ;
30435 PyObject * obj1 = 0 ;
30436 PyObject * obj2 = 0 ;
30437 char * kwnames[] = {
30438 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30439 };
30440
30441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30443 if (!SWIG_IsOK(res1)) {
30444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30445 }
30446 arg1 = reinterpret_cast< wxWindow * >(argp1);
30447 {
30448 arg2 = &temp2;
30449 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30450 }
30451 if (obj2) {
30452 ecode3 = SWIG_AsVal_int(obj2, &val3);
30453 if (!SWIG_IsOK(ecode3)) {
30454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30455 }
30456 arg3 = static_cast< int >(val3);
30457 }
30458 {
30459 PyThreadState* __tstate = wxPyBeginAllowThreads();
30460 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30461 wxPyEndAllowThreads(__tstate);
30462 if (PyErr_Occurred()) SWIG_fail;
30463 }
30464 resultobj = SWIG_Py_Void();
30465 return resultobj;
30466 fail:
30467 return NULL;
30468 }
30469
30470
30471 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30472 PyObject *resultobj = 0;
30473 wxWindow *arg1 = (wxWindow *) 0 ;
30474 int arg2 ;
30475 int arg3 ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 int val2 ;
30479 int ecode2 = 0 ;
30480 int val3 ;
30481 int ecode3 = 0 ;
30482 PyObject * obj0 = 0 ;
30483 PyObject * obj1 = 0 ;
30484 PyObject * obj2 = 0 ;
30485 char * kwnames[] = {
30486 (char *) "self",(char *) "width",(char *) "height", NULL
30487 };
30488
30489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30491 if (!SWIG_IsOK(res1)) {
30492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30493 }
30494 arg1 = reinterpret_cast< wxWindow * >(argp1);
30495 ecode2 = SWIG_AsVal_int(obj1, &val2);
30496 if (!SWIG_IsOK(ecode2)) {
30497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30498 }
30499 arg2 = static_cast< int >(val2);
30500 ecode3 = SWIG_AsVal_int(obj2, &val3);
30501 if (!SWIG_IsOK(ecode3)) {
30502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30503 }
30504 arg3 = static_cast< int >(val3);
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 (arg1)->SetSize(arg2,arg3);
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 resultobj = SWIG_Py_Void();
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj = 0;
30520 wxWindow *arg1 = (wxWindow *) 0 ;
30521 wxPoint *arg2 = 0 ;
30522 int arg3 = (int) wxSIZE_USE_EXISTING ;
30523 void *argp1 = 0 ;
30524 int res1 = 0 ;
30525 wxPoint temp2 ;
30526 int val3 ;
30527 int ecode3 = 0 ;
30528 PyObject * obj0 = 0 ;
30529 PyObject * obj1 = 0 ;
30530 PyObject * obj2 = 0 ;
30531 char * kwnames[] = {
30532 (char *) "self",(char *) "pt",(char *) "flags", NULL
30533 };
30534
30535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 {
30542 arg2 = &temp2;
30543 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30544 }
30545 if (obj2) {
30546 ecode3 = SWIG_AsVal_int(obj2, &val3);
30547 if (!SWIG_IsOK(ecode3)) {
30548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30549 }
30550 arg3 = static_cast< int >(val3);
30551 }
30552 {
30553 PyThreadState* __tstate = wxPyBeginAllowThreads();
30554 (arg1)->Move((wxPoint const &)*arg2,arg3);
30555 wxPyEndAllowThreads(__tstate);
30556 if (PyErr_Occurred()) SWIG_fail;
30557 }
30558 resultobj = SWIG_Py_Void();
30559 return resultobj;
30560 fail:
30561 return NULL;
30562 }
30563
30564
30565 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30566 PyObject *resultobj = 0;
30567 wxWindow *arg1 = (wxWindow *) 0 ;
30568 int arg2 ;
30569 int arg3 ;
30570 int arg4 = (int) wxSIZE_USE_EXISTING ;
30571 void *argp1 = 0 ;
30572 int res1 = 0 ;
30573 int val2 ;
30574 int ecode2 = 0 ;
30575 int val3 ;
30576 int ecode3 = 0 ;
30577 int val4 ;
30578 int ecode4 = 0 ;
30579 PyObject * obj0 = 0 ;
30580 PyObject * obj1 = 0 ;
30581 PyObject * obj2 = 0 ;
30582 PyObject * obj3 = 0 ;
30583 char * kwnames[] = {
30584 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30585 };
30586
30587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30589 if (!SWIG_IsOK(res1)) {
30590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30591 }
30592 arg1 = reinterpret_cast< wxWindow * >(argp1);
30593 ecode2 = SWIG_AsVal_int(obj1, &val2);
30594 if (!SWIG_IsOK(ecode2)) {
30595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30596 }
30597 arg2 = static_cast< int >(val2);
30598 ecode3 = SWIG_AsVal_int(obj2, &val3);
30599 if (!SWIG_IsOK(ecode3)) {
30600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30601 }
30602 arg3 = static_cast< int >(val3);
30603 if (obj3) {
30604 ecode4 = SWIG_AsVal_int(obj3, &val4);
30605 if (!SWIG_IsOK(ecode4)) {
30606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30607 }
30608 arg4 = static_cast< int >(val4);
30609 }
30610 {
30611 PyThreadState* __tstate = wxPyBeginAllowThreads();
30612 (arg1)->Move(arg2,arg3,arg4);
30613 wxPyEndAllowThreads(__tstate);
30614 if (PyErr_Occurred()) SWIG_fail;
30615 }
30616 resultobj = SWIG_Py_Void();
30617 return resultobj;
30618 fail:
30619 return NULL;
30620 }
30621
30622
30623 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30624 PyObject *resultobj = 0;
30625 wxWindow *arg1 = (wxWindow *) 0 ;
30626 wxSize const &arg2_defvalue = wxDefaultSize ;
30627 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30628 void *argp1 = 0 ;
30629 int res1 = 0 ;
30630 wxSize temp2 ;
30631 PyObject * obj0 = 0 ;
30632 PyObject * obj1 = 0 ;
30633 char * kwnames[] = {
30634 (char *) "self",(char *) "size", NULL
30635 };
30636
30637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30639 if (!SWIG_IsOK(res1)) {
30640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30641 }
30642 arg1 = reinterpret_cast< wxWindow * >(argp1);
30643 if (obj1) {
30644 {
30645 arg2 = &temp2;
30646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30647 }
30648 }
30649 {
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_Py_Void();
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30663 PyObject *resultobj = 0;
30664 wxWindow *arg1 = (wxWindow *) 0 ;
30665 void *argp1 = 0 ;
30666 int res1 = 0 ;
30667 PyObject *swig_obj[1] ;
30668
30669 if (!args) SWIG_fail;
30670 swig_obj[0] = args;
30671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30672 if (!SWIG_IsOK(res1)) {
30673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30674 }
30675 arg1 = reinterpret_cast< wxWindow * >(argp1);
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 (arg1)->Raise();
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 resultobj = SWIG_Py_Void();
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30690 PyObject *resultobj = 0;
30691 wxWindow *arg1 = (wxWindow *) 0 ;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 PyObject *swig_obj[1] ;
30695
30696 if (!args) SWIG_fail;
30697 swig_obj[0] = args;
30698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30701 }
30702 arg1 = reinterpret_cast< wxWindow * >(argp1);
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 (arg1)->Lower();
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_Py_Void();
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj = 0;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 wxSize *arg2 = 0 ;
30720 void *argp1 = 0 ;
30721 int res1 = 0 ;
30722 wxSize temp2 ;
30723 PyObject * obj0 = 0 ;
30724 PyObject * obj1 = 0 ;
30725 char * kwnames[] = {
30726 (char *) "self",(char *) "size", NULL
30727 };
30728
30729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30731 if (!SWIG_IsOK(res1)) {
30732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30733 }
30734 arg1 = reinterpret_cast< wxWindow * >(argp1);
30735 {
30736 arg2 = &temp2;
30737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30738 }
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 (arg1)->SetClientSize((wxSize const &)*arg2);
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 resultobj = SWIG_Py_Void();
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30753 PyObject *resultobj = 0;
30754 wxWindow *arg1 = (wxWindow *) 0 ;
30755 int arg2 ;
30756 int arg3 ;
30757 void *argp1 = 0 ;
30758 int res1 = 0 ;
30759 int val2 ;
30760 int ecode2 = 0 ;
30761 int val3 ;
30762 int ecode3 = 0 ;
30763 PyObject * obj0 = 0 ;
30764 PyObject * obj1 = 0 ;
30765 PyObject * obj2 = 0 ;
30766 char * kwnames[] = {
30767 (char *) "self",(char *) "width",(char *) "height", NULL
30768 };
30769
30770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30772 if (!SWIG_IsOK(res1)) {
30773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30774 }
30775 arg1 = reinterpret_cast< wxWindow * >(argp1);
30776 ecode2 = SWIG_AsVal_int(obj1, &val2);
30777 if (!SWIG_IsOK(ecode2)) {
30778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30779 }
30780 arg2 = static_cast< int >(val2);
30781 ecode3 = SWIG_AsVal_int(obj2, &val3);
30782 if (!SWIG_IsOK(ecode3)) {
30783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30784 }
30785 arg3 = static_cast< int >(val3);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 (arg1)->SetClientSize(arg2,arg3);
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 resultobj = SWIG_Py_Void();
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30800 PyObject *resultobj = 0;
30801 wxWindow *arg1 = (wxWindow *) 0 ;
30802 wxRect *arg2 = 0 ;
30803 void *argp1 = 0 ;
30804 int res1 = 0 ;
30805 wxRect temp2 ;
30806 PyObject * obj0 = 0 ;
30807 PyObject * obj1 = 0 ;
30808 char * kwnames[] = {
30809 (char *) "self",(char *) "rect", NULL
30810 };
30811
30812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30814 if (!SWIG_IsOK(res1)) {
30815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30816 }
30817 arg1 = reinterpret_cast< wxWindow * >(argp1);
30818 {
30819 arg2 = &temp2;
30820 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30821 }
30822 {
30823 PyThreadState* __tstate = wxPyBeginAllowThreads();
30824 (arg1)->SetClientSize((wxRect const &)*arg2);
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 resultobj = SWIG_Py_Void();
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30836 PyObject *resultobj = 0;
30837 wxWindow *arg1 = (wxWindow *) 0 ;
30838 wxPoint result;
30839 void *argp1 = 0 ;
30840 int res1 = 0 ;
30841 PyObject *swig_obj[1] ;
30842
30843 if (!args) SWIG_fail;
30844 swig_obj[0] = args;
30845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30846 if (!SWIG_IsOK(res1)) {
30847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30848 }
30849 arg1 = reinterpret_cast< wxWindow * >(argp1);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 result = ((wxWindow const *)arg1)->GetPosition();
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30864 PyObject *resultobj = 0;
30865 wxWindow *arg1 = (wxWindow *) 0 ;
30866 int *arg2 = (int *) 0 ;
30867 int *arg3 = (int *) 0 ;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 int temp2 ;
30871 int res2 = SWIG_TMPOBJ ;
30872 int temp3 ;
30873 int res3 = SWIG_TMPOBJ ;
30874 PyObject *swig_obj[1] ;
30875
30876 arg2 = &temp2;
30877 arg3 = &temp3;
30878 if (!args) SWIG_fail;
30879 swig_obj[0] = args;
30880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30883 }
30884 arg1 = reinterpret_cast< wxWindow * >(argp1);
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 resultobj = SWIG_Py_Void();
30892 if (SWIG_IsTmpObj(res2)) {
30893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30894 } else {
30895 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30897 }
30898 if (SWIG_IsTmpObj(res3)) {
30899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30900 } else {
30901 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxWindow *arg1 = (wxWindow *) 0 ;
30913 wxPoint result;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 PyObject *swig_obj[1] ;
30917
30918 if (!args) SWIG_fail;
30919 swig_obj[0] = args;
30920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30923 }
30924 arg1 = reinterpret_cast< wxWindow * >(argp1);
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = ((wxWindow const *)arg1)->GetScreenPosition();
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30932 return resultobj;
30933 fail:
30934 return NULL;
30935 }
30936
30937
30938 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30939 PyObject *resultobj = 0;
30940 wxWindow *arg1 = (wxWindow *) 0 ;
30941 int *arg2 = (int *) 0 ;
30942 int *arg3 = (int *) 0 ;
30943 void *argp1 = 0 ;
30944 int res1 = 0 ;
30945 int temp2 ;
30946 int res2 = SWIG_TMPOBJ ;
30947 int temp3 ;
30948 int res3 = SWIG_TMPOBJ ;
30949 PyObject *swig_obj[1] ;
30950
30951 arg2 = &temp2;
30952 arg3 = &temp3;
30953 if (!args) SWIG_fail;
30954 swig_obj[0] = args;
30955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30956 if (!SWIG_IsOK(res1)) {
30957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30958 }
30959 arg1 = reinterpret_cast< wxWindow * >(argp1);
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 resultobj = SWIG_Py_Void();
30967 if (SWIG_IsTmpObj(res2)) {
30968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30969 } else {
30970 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30972 }
30973 if (SWIG_IsTmpObj(res3)) {
30974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30975 } else {
30976 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30978 }
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30986 PyObject *resultobj = 0;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 wxRect result;
30989 void *argp1 = 0 ;
30990 int res1 = 0 ;
30991 PyObject *swig_obj[1] ;
30992
30993 if (!args) SWIG_fail;
30994 swig_obj[0] = args;
30995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30996 if (!SWIG_IsOK(res1)) {
30997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30998 }
30999 arg1 = reinterpret_cast< wxWindow * >(argp1);
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = ((wxWindow const *)arg1)->GetScreenRect();
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 PyObject *resultobj = 0;
31015 wxWindow *arg1 = (wxWindow *) 0 ;
31016 wxSize result;
31017 void *argp1 = 0 ;
31018 int res1 = 0 ;
31019 PyObject *swig_obj[1] ;
31020
31021 if (!args) SWIG_fail;
31022 swig_obj[0] = args;
31023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31024 if (!SWIG_IsOK(res1)) {
31025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31026 }
31027 arg1 = reinterpret_cast< wxWindow * >(argp1);
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 result = ((wxWindow const *)arg1)->GetSize();
31031 wxPyEndAllowThreads(__tstate);
31032 if (PyErr_Occurred()) SWIG_fail;
31033 }
31034 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31035 return resultobj;
31036 fail:
31037 return NULL;
31038 }
31039
31040
31041 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31042 PyObject *resultobj = 0;
31043 wxWindow *arg1 = (wxWindow *) 0 ;
31044 int *arg2 = (int *) 0 ;
31045 int *arg3 = (int *) 0 ;
31046 void *argp1 = 0 ;
31047 int res1 = 0 ;
31048 int temp2 ;
31049 int res2 = SWIG_TMPOBJ ;
31050 int temp3 ;
31051 int res3 = SWIG_TMPOBJ ;
31052 PyObject *swig_obj[1] ;
31053
31054 arg2 = &temp2;
31055 arg3 = &temp3;
31056 if (!args) SWIG_fail;
31057 swig_obj[0] = args;
31058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31059 if (!SWIG_IsOK(res1)) {
31060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31061 }
31062 arg1 = reinterpret_cast< wxWindow * >(argp1);
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 resultobj = SWIG_Py_Void();
31070 if (SWIG_IsTmpObj(res2)) {
31071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31072 } else {
31073 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31075 }
31076 if (SWIG_IsTmpObj(res3)) {
31077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31078 } else {
31079 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31081 }
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31089 PyObject *resultobj = 0;
31090 wxWindow *arg1 = (wxWindow *) 0 ;
31091 wxRect result;
31092 void *argp1 = 0 ;
31093 int res1 = 0 ;
31094 PyObject *swig_obj[1] ;
31095
31096 if (!args) SWIG_fail;
31097 swig_obj[0] = args;
31098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31099 if (!SWIG_IsOK(res1)) {
31100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31101 }
31102 arg1 = reinterpret_cast< wxWindow * >(argp1);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 result = ((wxWindow const *)arg1)->GetRect();
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxSize result;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 PyObject *swig_obj[1] ;
31123
31124 if (!args) SWIG_fail;
31125 swig_obj[0] = args;
31126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31127 if (!SWIG_IsOK(res1)) {
31128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31129 }
31130 arg1 = reinterpret_cast< wxWindow * >(argp1);
31131 {
31132 PyThreadState* __tstate = wxPyBeginAllowThreads();
31133 result = ((wxWindow const *)arg1)->GetClientSize();
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31145 PyObject *resultobj = 0;
31146 wxWindow *arg1 = (wxWindow *) 0 ;
31147 int *arg2 = (int *) 0 ;
31148 int *arg3 = (int *) 0 ;
31149 void *argp1 = 0 ;
31150 int res1 = 0 ;
31151 int temp2 ;
31152 int res2 = SWIG_TMPOBJ ;
31153 int temp3 ;
31154 int res3 = SWIG_TMPOBJ ;
31155 PyObject *swig_obj[1] ;
31156
31157 arg2 = &temp2;
31158 arg3 = &temp3;
31159 if (!args) SWIG_fail;
31160 swig_obj[0] = args;
31161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31162 if (!SWIG_IsOK(res1)) {
31163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31164 }
31165 arg1 = reinterpret_cast< wxWindow * >(argp1);
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31169 wxPyEndAllowThreads(__tstate);
31170 if (PyErr_Occurred()) SWIG_fail;
31171 }
31172 resultobj = SWIG_Py_Void();
31173 if (SWIG_IsTmpObj(res2)) {
31174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31175 } else {
31176 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31178 }
31179 if (SWIG_IsTmpObj(res3)) {
31180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31181 } else {
31182 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31184 }
31185 return resultobj;
31186 fail:
31187 return NULL;
31188 }
31189
31190
31191 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31192 PyObject *resultobj = 0;
31193 wxWindow *arg1 = (wxWindow *) 0 ;
31194 wxPoint result;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 PyObject *swig_obj[1] ;
31198
31199 if (!args) SWIG_fail;
31200 swig_obj[0] = args;
31201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31202 if (!SWIG_IsOK(res1)) {
31203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31204 }
31205 arg1 = reinterpret_cast< wxWindow * >(argp1);
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31220 PyObject *resultobj = 0;
31221 wxWindow *arg1 = (wxWindow *) 0 ;
31222 wxRect result;
31223 void *argp1 = 0 ;
31224 int res1 = 0 ;
31225 PyObject *swig_obj[1] ;
31226
31227 if (!args) SWIG_fail;
31228 swig_obj[0] = args;
31229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31230 if (!SWIG_IsOK(res1)) {
31231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31232 }
31233 arg1 = reinterpret_cast< wxWindow * >(argp1);
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = ((wxWindow const *)arg1)->GetClientRect();
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxWindow *arg1 = (wxWindow *) 0 ;
31250 wxSize result;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 PyObject *swig_obj[1] ;
31254
31255 if (!args) SWIG_fail;
31256 swig_obj[0] = args;
31257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31258 if (!SWIG_IsOK(res1)) {
31259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31260 }
31261 arg1 = reinterpret_cast< wxWindow * >(argp1);
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 result = ((wxWindow const *)arg1)->GetBestSize();
31265 wxPyEndAllowThreads(__tstate);
31266 if (PyErr_Occurred()) SWIG_fail;
31267 }
31268 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31269 return resultobj;
31270 fail:
31271 return NULL;
31272 }
31273
31274
31275 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31276 PyObject *resultobj = 0;
31277 wxWindow *arg1 = (wxWindow *) 0 ;
31278 int *arg2 = (int *) 0 ;
31279 int *arg3 = (int *) 0 ;
31280 void *argp1 = 0 ;
31281 int res1 = 0 ;
31282 int temp2 ;
31283 int res2 = SWIG_TMPOBJ ;
31284 int temp3 ;
31285 int res3 = SWIG_TMPOBJ ;
31286 PyObject *swig_obj[1] ;
31287
31288 arg2 = &temp2;
31289 arg3 = &temp3;
31290 if (!args) SWIG_fail;
31291 swig_obj[0] = args;
31292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31295 }
31296 arg1 = reinterpret_cast< wxWindow * >(argp1);
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_Py_Void();
31304 if (SWIG_IsTmpObj(res2)) {
31305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31306 } else {
31307 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31309 }
31310 if (SWIG_IsTmpObj(res3)) {
31311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31312 } else {
31313 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31315 }
31316 return resultobj;
31317 fail:
31318 return NULL;
31319 }
31320
31321
31322 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31323 PyObject *resultobj = 0;
31324 wxWindow *arg1 = (wxWindow *) 0 ;
31325 void *argp1 = 0 ;
31326 int res1 = 0 ;
31327 PyObject *swig_obj[1] ;
31328
31329 if (!args) SWIG_fail;
31330 swig_obj[0] = args;
31331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31332 if (!SWIG_IsOK(res1)) {
31333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31334 }
31335 arg1 = reinterpret_cast< wxWindow * >(argp1);
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 (arg1)->InvalidateBestSize();
31339 wxPyEndAllowThreads(__tstate);
31340 if (PyErr_Occurred()) SWIG_fail;
31341 }
31342 resultobj = SWIG_Py_Void();
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31350 PyObject *resultobj = 0;
31351 wxWindow *arg1 = (wxWindow *) 0 ;
31352 wxSize *arg2 = 0 ;
31353 void *argp1 = 0 ;
31354 int res1 = 0 ;
31355 wxSize temp2 ;
31356 PyObject * obj0 = 0 ;
31357 PyObject * obj1 = 0 ;
31358 char * kwnames[] = {
31359 (char *) "self",(char *) "size", NULL
31360 };
31361
31362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31364 if (!SWIG_IsOK(res1)) {
31365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31366 }
31367 arg1 = reinterpret_cast< wxWindow * >(argp1);
31368 {
31369 arg2 = &temp2;
31370 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31371 }
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_Py_Void();
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *resultobj = 0;
31387 wxWindow *arg1 = (wxWindow *) 0 ;
31388 wxSize result;
31389 void *argp1 = 0 ;
31390 int res1 = 0 ;
31391 PyObject *swig_obj[1] ;
31392
31393 if (!args) SWIG_fail;
31394 swig_obj[0] = args;
31395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31396 if (!SWIG_IsOK(res1)) {
31397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31398 }
31399 arg1 = reinterpret_cast< wxWindow * >(argp1);
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31414 PyObject *resultobj = 0;
31415 wxWindow *arg1 = (wxWindow *) 0 ;
31416 wxSize result;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 PyObject *swig_obj[1] ;
31420
31421 if (!args) SWIG_fail;
31422 swig_obj[0] = args;
31423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31424 if (!SWIG_IsOK(res1)) {
31425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31426 }
31427 arg1 = reinterpret_cast< wxWindow * >(argp1);
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31442 PyObject *resultobj = 0;
31443 wxWindow *arg1 = (wxWindow *) 0 ;
31444 int arg2 = (int) wxBOTH ;
31445 void *argp1 = 0 ;
31446 int res1 = 0 ;
31447 int val2 ;
31448 int ecode2 = 0 ;
31449 PyObject * obj0 = 0 ;
31450 PyObject * obj1 = 0 ;
31451 char * kwnames[] = {
31452 (char *) "self",(char *) "direction", NULL
31453 };
31454
31455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31457 if (!SWIG_IsOK(res1)) {
31458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31459 }
31460 arg1 = reinterpret_cast< wxWindow * >(argp1);
31461 if (obj1) {
31462 ecode2 = SWIG_AsVal_int(obj1, &val2);
31463 if (!SWIG_IsOK(ecode2)) {
31464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31465 }
31466 arg2 = static_cast< int >(val2);
31467 }
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 (arg1)->Center(arg2);
31471 wxPyEndAllowThreads(__tstate);
31472 if (PyErr_Occurred()) SWIG_fail;
31473 }
31474 resultobj = SWIG_Py_Void();
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31482 PyObject *resultobj = 0;
31483 wxWindow *arg1 = (wxWindow *) 0 ;
31484 int arg2 = (int) wxBOTH ;
31485 void *argp1 = 0 ;
31486 int res1 = 0 ;
31487 int val2 ;
31488 int ecode2 = 0 ;
31489 PyObject * obj0 = 0 ;
31490 PyObject * obj1 = 0 ;
31491 char * kwnames[] = {
31492 (char *) "self",(char *) "dir", NULL
31493 };
31494
31495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31497 if (!SWIG_IsOK(res1)) {
31498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31499 }
31500 arg1 = reinterpret_cast< wxWindow * >(argp1);
31501 if (obj1) {
31502 ecode2 = SWIG_AsVal_int(obj1, &val2);
31503 if (!SWIG_IsOK(ecode2)) {
31504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31505 }
31506 arg2 = static_cast< int >(val2);
31507 }
31508 {
31509 PyThreadState* __tstate = wxPyBeginAllowThreads();
31510 (arg1)->CenterOnParent(arg2);
31511 wxPyEndAllowThreads(__tstate);
31512 if (PyErr_Occurred()) SWIG_fail;
31513 }
31514 resultobj = SWIG_Py_Void();
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31522 PyObject *resultobj = 0;
31523 wxWindow *arg1 = (wxWindow *) 0 ;
31524 void *argp1 = 0 ;
31525 int res1 = 0 ;
31526 PyObject *swig_obj[1] ;
31527
31528 if (!args) SWIG_fail;
31529 swig_obj[0] = args;
31530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31531 if (!SWIG_IsOK(res1)) {
31532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31533 }
31534 arg1 = reinterpret_cast< wxWindow * >(argp1);
31535 {
31536 PyThreadState* __tstate = wxPyBeginAllowThreads();
31537 (arg1)->Fit();
31538 wxPyEndAllowThreads(__tstate);
31539 if (PyErr_Occurred()) SWIG_fail;
31540 }
31541 resultobj = SWIG_Py_Void();
31542 return resultobj;
31543 fail:
31544 return NULL;
31545 }
31546
31547
31548 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31549 PyObject *resultobj = 0;
31550 wxWindow *arg1 = (wxWindow *) 0 ;
31551 void *argp1 = 0 ;
31552 int res1 = 0 ;
31553 PyObject *swig_obj[1] ;
31554
31555 if (!args) SWIG_fail;
31556 swig_obj[0] = args;
31557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31558 if (!SWIG_IsOK(res1)) {
31559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31560 }
31561 arg1 = reinterpret_cast< wxWindow * >(argp1);
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 (arg1)->FitInside();
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_Py_Void();
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31576 PyObject *resultobj = 0;
31577 wxWindow *arg1 = (wxWindow *) 0 ;
31578 int arg2 ;
31579 int arg3 ;
31580 int arg4 = (int) -1 ;
31581 int arg5 = (int) -1 ;
31582 int arg6 = (int) -1 ;
31583 int arg7 = (int) -1 ;
31584 void *argp1 = 0 ;
31585 int res1 = 0 ;
31586 int val2 ;
31587 int ecode2 = 0 ;
31588 int val3 ;
31589 int ecode3 = 0 ;
31590 int val4 ;
31591 int ecode4 = 0 ;
31592 int val5 ;
31593 int ecode5 = 0 ;
31594 int val6 ;
31595 int ecode6 = 0 ;
31596 int val7 ;
31597 int ecode7 = 0 ;
31598 PyObject * obj0 = 0 ;
31599 PyObject * obj1 = 0 ;
31600 PyObject * obj2 = 0 ;
31601 PyObject * obj3 = 0 ;
31602 PyObject * obj4 = 0 ;
31603 PyObject * obj5 = 0 ;
31604 PyObject * obj6 = 0 ;
31605 char * kwnames[] = {
31606 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31607 };
31608
31609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31611 if (!SWIG_IsOK(res1)) {
31612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31613 }
31614 arg1 = reinterpret_cast< wxWindow * >(argp1);
31615 ecode2 = SWIG_AsVal_int(obj1, &val2);
31616 if (!SWIG_IsOK(ecode2)) {
31617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31618 }
31619 arg2 = static_cast< int >(val2);
31620 ecode3 = SWIG_AsVal_int(obj2, &val3);
31621 if (!SWIG_IsOK(ecode3)) {
31622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31623 }
31624 arg3 = static_cast< int >(val3);
31625 if (obj3) {
31626 ecode4 = SWIG_AsVal_int(obj3, &val4);
31627 if (!SWIG_IsOK(ecode4)) {
31628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31629 }
31630 arg4 = static_cast< int >(val4);
31631 }
31632 if (obj4) {
31633 ecode5 = SWIG_AsVal_int(obj4, &val5);
31634 if (!SWIG_IsOK(ecode5)) {
31635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31636 }
31637 arg5 = static_cast< int >(val5);
31638 }
31639 if (obj5) {
31640 ecode6 = SWIG_AsVal_int(obj5, &val6);
31641 if (!SWIG_IsOK(ecode6)) {
31642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31643 }
31644 arg6 = static_cast< int >(val6);
31645 }
31646 if (obj6) {
31647 ecode7 = SWIG_AsVal_int(obj6, &val7);
31648 if (!SWIG_IsOK(ecode7)) {
31649 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31650 }
31651 arg7 = static_cast< int >(val7);
31652 }
31653 {
31654 PyThreadState* __tstate = wxPyBeginAllowThreads();
31655 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31656 wxPyEndAllowThreads(__tstate);
31657 if (PyErr_Occurred()) SWIG_fail;
31658 }
31659 resultobj = SWIG_Py_Void();
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31667 PyObject *resultobj = 0;
31668 wxWindow *arg1 = (wxWindow *) 0 ;
31669 wxSize *arg2 = 0 ;
31670 wxSize const &arg3_defvalue = wxDefaultSize ;
31671 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31672 wxSize const &arg4_defvalue = wxDefaultSize ;
31673 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31674 void *argp1 = 0 ;
31675 int res1 = 0 ;
31676 wxSize temp2 ;
31677 wxSize temp3 ;
31678 wxSize temp4 ;
31679 PyObject * obj0 = 0 ;
31680 PyObject * obj1 = 0 ;
31681 PyObject * obj2 = 0 ;
31682 PyObject * obj3 = 0 ;
31683 char * kwnames[] = {
31684 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31685 };
31686
31687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31689 if (!SWIG_IsOK(res1)) {
31690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31691 }
31692 arg1 = reinterpret_cast< wxWindow * >(argp1);
31693 {
31694 arg2 = &temp2;
31695 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31696 }
31697 if (obj2) {
31698 {
31699 arg3 = &temp3;
31700 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31701 }
31702 }
31703 if (obj3) {
31704 {
31705 arg4 = &temp4;
31706 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31707 }
31708 }
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 resultobj = SWIG_Py_Void();
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31723 PyObject *resultobj = 0;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 int arg2 ;
31726 int arg3 ;
31727 int arg4 = (int) -1 ;
31728 int arg5 = (int) -1 ;
31729 void *argp1 = 0 ;
31730 int res1 = 0 ;
31731 int val2 ;
31732 int ecode2 = 0 ;
31733 int val3 ;
31734 int ecode3 = 0 ;
31735 int val4 ;
31736 int ecode4 = 0 ;
31737 int val5 ;
31738 int ecode5 = 0 ;
31739 PyObject * obj0 = 0 ;
31740 PyObject * obj1 = 0 ;
31741 PyObject * obj2 = 0 ;
31742 PyObject * obj3 = 0 ;
31743 PyObject * obj4 = 0 ;
31744 char * kwnames[] = {
31745 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31746 };
31747
31748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31750 if (!SWIG_IsOK(res1)) {
31751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31752 }
31753 arg1 = reinterpret_cast< wxWindow * >(argp1);
31754 ecode2 = SWIG_AsVal_int(obj1, &val2);
31755 if (!SWIG_IsOK(ecode2)) {
31756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31757 }
31758 arg2 = static_cast< int >(val2);
31759 ecode3 = SWIG_AsVal_int(obj2, &val3);
31760 if (!SWIG_IsOK(ecode3)) {
31761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31762 }
31763 arg3 = static_cast< int >(val3);
31764 if (obj3) {
31765 ecode4 = SWIG_AsVal_int(obj3, &val4);
31766 if (!SWIG_IsOK(ecode4)) {
31767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31768 }
31769 arg4 = static_cast< int >(val4);
31770 }
31771 if (obj4) {
31772 ecode5 = SWIG_AsVal_int(obj4, &val5);
31773 if (!SWIG_IsOK(ecode5)) {
31774 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31775 }
31776 arg5 = static_cast< int >(val5);
31777 }
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 resultobj = SWIG_Py_Void();
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31792 PyObject *resultobj = 0;
31793 wxWindow *arg1 = (wxWindow *) 0 ;
31794 wxSize *arg2 = 0 ;
31795 wxSize const &arg3_defvalue = wxDefaultSize ;
31796 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31797 void *argp1 = 0 ;
31798 int res1 = 0 ;
31799 wxSize temp2 ;
31800 wxSize temp3 ;
31801 PyObject * obj0 = 0 ;
31802 PyObject * obj1 = 0 ;
31803 PyObject * obj2 = 0 ;
31804 char * kwnames[] = {
31805 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31806 };
31807
31808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31810 if (!SWIG_IsOK(res1)) {
31811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31812 }
31813 arg1 = reinterpret_cast< wxWindow * >(argp1);
31814 {
31815 arg2 = &temp2;
31816 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31817 }
31818 if (obj2) {
31819 {
31820 arg3 = &temp3;
31821 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31822 }
31823 }
31824 {
31825 PyThreadState* __tstate = wxPyBeginAllowThreads();
31826 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31827 wxPyEndAllowThreads(__tstate);
31828 if (PyErr_Occurred()) SWIG_fail;
31829 }
31830 resultobj = SWIG_Py_Void();
31831 return resultobj;
31832 fail:
31833 return NULL;
31834 }
31835
31836
31837 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31838 PyObject *resultobj = 0;
31839 wxWindow *arg1 = (wxWindow *) 0 ;
31840 wxSize result;
31841 void *argp1 = 0 ;
31842 int res1 = 0 ;
31843 PyObject *swig_obj[1] ;
31844
31845 if (!args) SWIG_fail;
31846 swig_obj[0] = args;
31847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31848 if (!SWIG_IsOK(res1)) {
31849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31850 }
31851 arg1 = reinterpret_cast< wxWindow * >(argp1);
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 result = ((wxWindow const *)arg1)->GetMaxSize();
31855 wxPyEndAllowThreads(__tstate);
31856 if (PyErr_Occurred()) SWIG_fail;
31857 }
31858 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31859 return resultobj;
31860 fail:
31861 return NULL;
31862 }
31863
31864
31865 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31866 PyObject *resultobj = 0;
31867 wxWindow *arg1 = (wxWindow *) 0 ;
31868 wxSize result;
31869 void *argp1 = 0 ;
31870 int res1 = 0 ;
31871 PyObject *swig_obj[1] ;
31872
31873 if (!args) SWIG_fail;
31874 swig_obj[0] = args;
31875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31876 if (!SWIG_IsOK(res1)) {
31877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31878 }
31879 arg1 = reinterpret_cast< wxWindow * >(argp1);
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 result = ((wxWindow const *)arg1)->GetMinSize();
31883 wxPyEndAllowThreads(__tstate);
31884 if (PyErr_Occurred()) SWIG_fail;
31885 }
31886 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31887 return resultobj;
31888 fail:
31889 return NULL;
31890 }
31891
31892
31893 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31894 PyObject *resultobj = 0;
31895 wxWindow *arg1 = (wxWindow *) 0 ;
31896 wxSize *arg2 = 0 ;
31897 void *argp1 = 0 ;
31898 int res1 = 0 ;
31899 wxSize temp2 ;
31900 PyObject * obj0 = 0 ;
31901 PyObject * obj1 = 0 ;
31902 char * kwnames[] = {
31903 (char *) "self",(char *) "minSize", NULL
31904 };
31905
31906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31908 if (!SWIG_IsOK(res1)) {
31909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31910 }
31911 arg1 = reinterpret_cast< wxWindow * >(argp1);
31912 {
31913 arg2 = &temp2;
31914 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31915 }
31916 {
31917 PyThreadState* __tstate = wxPyBeginAllowThreads();
31918 (arg1)->SetMinSize((wxSize const &)*arg2);
31919 wxPyEndAllowThreads(__tstate);
31920 if (PyErr_Occurred()) SWIG_fail;
31921 }
31922 resultobj = SWIG_Py_Void();
31923 return resultobj;
31924 fail:
31925 return NULL;
31926 }
31927
31928
31929 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31930 PyObject *resultobj = 0;
31931 wxWindow *arg1 = (wxWindow *) 0 ;
31932 wxSize *arg2 = 0 ;
31933 void *argp1 = 0 ;
31934 int res1 = 0 ;
31935 wxSize temp2 ;
31936 PyObject * obj0 = 0 ;
31937 PyObject * obj1 = 0 ;
31938 char * kwnames[] = {
31939 (char *) "self",(char *) "maxSize", NULL
31940 };
31941
31942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31944 if (!SWIG_IsOK(res1)) {
31945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31946 }
31947 arg1 = reinterpret_cast< wxWindow * >(argp1);
31948 {
31949 arg2 = &temp2;
31950 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31951 }
31952 {
31953 PyThreadState* __tstate = wxPyBeginAllowThreads();
31954 (arg1)->SetMaxSize((wxSize const &)*arg2);
31955 wxPyEndAllowThreads(__tstate);
31956 if (PyErr_Occurred()) SWIG_fail;
31957 }
31958 resultobj = SWIG_Py_Void();
31959 return resultobj;
31960 fail:
31961 return NULL;
31962 }
31963
31964
31965 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31966 PyObject *resultobj = 0;
31967 wxWindow *arg1 = (wxWindow *) 0 ;
31968 int result;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971 PyObject *swig_obj[1] ;
31972
31973 if (!args) SWIG_fail;
31974 swig_obj[0] = args;
31975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31976 if (!SWIG_IsOK(res1)) {
31977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31978 }
31979 arg1 = reinterpret_cast< wxWindow * >(argp1);
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 resultobj = SWIG_From_int(static_cast< int >(result));
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 PyObject *resultobj = 0;
31995 wxWindow *arg1 = (wxWindow *) 0 ;
31996 int result;
31997 void *argp1 = 0 ;
31998 int res1 = 0 ;
31999 PyObject *swig_obj[1] ;
32000
32001 if (!args) SWIG_fail;
32002 swig_obj[0] = args;
32003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32004 if (!SWIG_IsOK(res1)) {
32005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32006 }
32007 arg1 = reinterpret_cast< wxWindow * >(argp1);
32008 {
32009 PyThreadState* __tstate = wxPyBeginAllowThreads();
32010 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 resultobj = SWIG_From_int(static_cast< int >(result));
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32022 PyObject *resultobj = 0;
32023 wxWindow *arg1 = (wxWindow *) 0 ;
32024 int result;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 PyObject *swig_obj[1] ;
32028
32029 if (!args) SWIG_fail;
32030 swig_obj[0] = args;
32031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32034 }
32035 arg1 = reinterpret_cast< wxWindow * >(argp1);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = SWIG_From_int(static_cast< int >(result));
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32050 PyObject *resultobj = 0;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 int result;
32053 void *argp1 = 0 ;
32054 int res1 = 0 ;
32055 PyObject *swig_obj[1] ;
32056
32057 if (!args) SWIG_fail;
32058 swig_obj[0] = args;
32059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32060 if (!SWIG_IsOK(res1)) {
32061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32062 }
32063 arg1 = reinterpret_cast< wxWindow * >(argp1);
32064 {
32065 PyThreadState* __tstate = wxPyBeginAllowThreads();
32066 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32067 wxPyEndAllowThreads(__tstate);
32068 if (PyErr_Occurred()) SWIG_fail;
32069 }
32070 resultobj = SWIG_From_int(static_cast< int >(result));
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32078 PyObject *resultobj = 0;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 wxSize *arg2 = 0 ;
32081 void *argp1 = 0 ;
32082 int res1 = 0 ;
32083 wxSize temp2 ;
32084 PyObject * obj0 = 0 ;
32085 PyObject * obj1 = 0 ;
32086 char * kwnames[] = {
32087 (char *) "self",(char *) "size", NULL
32088 };
32089
32090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32092 if (!SWIG_IsOK(res1)) {
32093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32094 }
32095 arg1 = reinterpret_cast< wxWindow * >(argp1);
32096 {
32097 arg2 = &temp2;
32098 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32099 }
32100 {
32101 PyThreadState* __tstate = wxPyBeginAllowThreads();
32102 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32103 wxPyEndAllowThreads(__tstate);
32104 if (PyErr_Occurred()) SWIG_fail;
32105 }
32106 resultobj = SWIG_Py_Void();
32107 return resultobj;
32108 fail:
32109 return NULL;
32110 }
32111
32112
32113 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32114 PyObject *resultobj = 0;
32115 wxWindow *arg1 = (wxWindow *) 0 ;
32116 int arg2 ;
32117 int arg3 ;
32118 void *argp1 = 0 ;
32119 int res1 = 0 ;
32120 int val2 ;
32121 int ecode2 = 0 ;
32122 int val3 ;
32123 int ecode3 = 0 ;
32124 PyObject * obj0 = 0 ;
32125 PyObject * obj1 = 0 ;
32126 PyObject * obj2 = 0 ;
32127 char * kwnames[] = {
32128 (char *) "self",(char *) "w",(char *) "h", NULL
32129 };
32130
32131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32133 if (!SWIG_IsOK(res1)) {
32134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32135 }
32136 arg1 = reinterpret_cast< wxWindow * >(argp1);
32137 ecode2 = SWIG_AsVal_int(obj1, &val2);
32138 if (!SWIG_IsOK(ecode2)) {
32139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32140 }
32141 arg2 = static_cast< int >(val2);
32142 ecode3 = SWIG_AsVal_int(obj2, &val3);
32143 if (!SWIG_IsOK(ecode3)) {
32144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32145 }
32146 arg3 = static_cast< int >(val3);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 (arg1)->SetVirtualSize(arg2,arg3);
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_Py_Void();
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxWindow *arg1 = (wxWindow *) 0 ;
32163 wxSize 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_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32173 }
32174 arg1 = reinterpret_cast< wxWindow * >(argp1);
32175 {
32176 PyThreadState* __tstate = wxPyBeginAllowThreads();
32177 result = ((wxWindow const *)arg1)->GetVirtualSize();
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32182 return resultobj;
32183 fail:
32184 return NULL;
32185 }
32186
32187
32188 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32189 PyObject *resultobj = 0;
32190 wxWindow *arg1 = (wxWindow *) 0 ;
32191 int *arg2 = (int *) 0 ;
32192 int *arg3 = (int *) 0 ;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 int temp2 ;
32196 int res2 = SWIG_TMPOBJ ;
32197 int temp3 ;
32198 int res3 = SWIG_TMPOBJ ;
32199 PyObject *swig_obj[1] ;
32200
32201 arg2 = &temp2;
32202 arg3 = &temp3;
32203 if (!args) SWIG_fail;
32204 swig_obj[0] = args;
32205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32206 if (!SWIG_IsOK(res1)) {
32207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32208 }
32209 arg1 = reinterpret_cast< wxWindow * >(argp1);
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 resultobj = SWIG_Py_Void();
32217 if (SWIG_IsTmpObj(res2)) {
32218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32219 } else {
32220 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32222 }
32223 if (SWIG_IsTmpObj(res3)) {
32224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32225 } else {
32226 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32228 }
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32236 PyObject *resultobj = 0;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 wxSize result;
32239 void *argp1 = 0 ;
32240 int res1 = 0 ;
32241 PyObject *swig_obj[1] ;
32242
32243 if (!args) SWIG_fail;
32244 swig_obj[0] = args;
32245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32246 if (!SWIG_IsOK(res1)) {
32247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32248 }
32249 arg1 = reinterpret_cast< wxWindow * >(argp1);
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32253 wxPyEndAllowThreads(__tstate);
32254 if (PyErr_Occurred()) SWIG_fail;
32255 }
32256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32264 PyObject *resultobj = 0;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 bool arg2 = (bool) true ;
32267 bool result;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 bool val2 ;
32271 int ecode2 = 0 ;
32272 PyObject * obj0 = 0 ;
32273 PyObject * obj1 = 0 ;
32274 char * kwnames[] = {
32275 (char *) "self",(char *) "show", NULL
32276 };
32277
32278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32280 if (!SWIG_IsOK(res1)) {
32281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32282 }
32283 arg1 = reinterpret_cast< wxWindow * >(argp1);
32284 if (obj1) {
32285 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32286 if (!SWIG_IsOK(ecode2)) {
32287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32288 }
32289 arg2 = static_cast< bool >(val2);
32290 }
32291 {
32292 PyThreadState* __tstate = wxPyBeginAllowThreads();
32293 result = (bool)(arg1)->Show(arg2);
32294 wxPyEndAllowThreads(__tstate);
32295 if (PyErr_Occurred()) SWIG_fail;
32296 }
32297 {
32298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32299 }
32300 return resultobj;
32301 fail:
32302 return NULL;
32303 }
32304
32305
32306 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32307 PyObject *resultobj = 0;
32308 wxWindow *arg1 = (wxWindow *) 0 ;
32309 bool result;
32310 void *argp1 = 0 ;
32311 int res1 = 0 ;
32312 PyObject *swig_obj[1] ;
32313
32314 if (!args) SWIG_fail;
32315 swig_obj[0] = args;
32316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32317 if (!SWIG_IsOK(res1)) {
32318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32319 }
32320 arg1 = reinterpret_cast< wxWindow * >(argp1);
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 result = (bool)(arg1)->Hide();
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 {
32328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32329 }
32330 return resultobj;
32331 fail:
32332 return NULL;
32333 }
32334
32335
32336 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32337 PyObject *resultobj = 0;
32338 wxWindow *arg1 = (wxWindow *) 0 ;
32339 bool arg2 = (bool) true ;
32340 bool result;
32341 void *argp1 = 0 ;
32342 int res1 = 0 ;
32343 bool val2 ;
32344 int ecode2 = 0 ;
32345 PyObject * obj0 = 0 ;
32346 PyObject * obj1 = 0 ;
32347 char * kwnames[] = {
32348 (char *) "self",(char *) "enable", NULL
32349 };
32350
32351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32353 if (!SWIG_IsOK(res1)) {
32354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32355 }
32356 arg1 = reinterpret_cast< wxWindow * >(argp1);
32357 if (obj1) {
32358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32359 if (!SWIG_IsOK(ecode2)) {
32360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32361 }
32362 arg2 = static_cast< bool >(val2);
32363 }
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = (bool)(arg1)->Enable(arg2);
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 {
32371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32372 }
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 PyObject *resultobj = 0;
32381 wxWindow *arg1 = (wxWindow *) 0 ;
32382 bool result;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 PyObject *swig_obj[1] ;
32386
32387 if (!args) SWIG_fail;
32388 swig_obj[0] = args;
32389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32392 }
32393 arg1 = reinterpret_cast< wxWindow * >(argp1);
32394 {
32395 PyThreadState* __tstate = wxPyBeginAllowThreads();
32396 result = (bool)(arg1)->Disable();
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 {
32401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32402 }
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *resultobj = 0;
32411 wxWindow *arg1 = (wxWindow *) 0 ;
32412 bool result;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 PyObject *swig_obj[1] ;
32416
32417 if (!args) SWIG_fail;
32418 swig_obj[0] = args;
32419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32422 }
32423 arg1 = reinterpret_cast< wxWindow * >(argp1);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = (bool)((wxWindow const *)arg1)->IsShown();
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 {
32431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32432 }
32433 return resultobj;
32434 fail:
32435 return NULL;
32436 }
32437
32438
32439 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32440 PyObject *resultobj = 0;
32441 wxWindow *arg1 = (wxWindow *) 0 ;
32442 bool result;
32443 void *argp1 = 0 ;
32444 int res1 = 0 ;
32445 PyObject *swig_obj[1] ;
32446
32447 if (!args) SWIG_fail;
32448 swig_obj[0] = args;
32449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32450 if (!SWIG_IsOK(res1)) {
32451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32452 }
32453 arg1 = reinterpret_cast< wxWindow * >(argp1);
32454 {
32455 PyThreadState* __tstate = wxPyBeginAllowThreads();
32456 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 {
32461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32462 }
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxWindow *arg1 = (wxWindow *) 0 ;
32472 long arg2 ;
32473 void *argp1 = 0 ;
32474 int res1 = 0 ;
32475 long val2 ;
32476 int ecode2 = 0 ;
32477 PyObject * obj0 = 0 ;
32478 PyObject * obj1 = 0 ;
32479 char * kwnames[] = {
32480 (char *) "self",(char *) "style", NULL
32481 };
32482
32483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32485 if (!SWIG_IsOK(res1)) {
32486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32487 }
32488 arg1 = reinterpret_cast< wxWindow * >(argp1);
32489 ecode2 = SWIG_AsVal_long(obj1, &val2);
32490 if (!SWIG_IsOK(ecode2)) {
32491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32492 }
32493 arg2 = static_cast< long >(val2);
32494 {
32495 PyThreadState* __tstate = wxPyBeginAllowThreads();
32496 (arg1)->SetWindowStyleFlag(arg2);
32497 wxPyEndAllowThreads(__tstate);
32498 if (PyErr_Occurred()) SWIG_fail;
32499 }
32500 resultobj = SWIG_Py_Void();
32501 return resultobj;
32502 fail:
32503 return NULL;
32504 }
32505
32506
32507 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32508 PyObject *resultobj = 0;
32509 wxWindow *arg1 = (wxWindow *) 0 ;
32510 long result;
32511 void *argp1 = 0 ;
32512 int res1 = 0 ;
32513 PyObject *swig_obj[1] ;
32514
32515 if (!args) SWIG_fail;
32516 swig_obj[0] = args;
32517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32518 if (!SWIG_IsOK(res1)) {
32519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32520 }
32521 arg1 = reinterpret_cast< wxWindow * >(argp1);
32522 {
32523 PyThreadState* __tstate = wxPyBeginAllowThreads();
32524 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32525 wxPyEndAllowThreads(__tstate);
32526 if (PyErr_Occurred()) SWIG_fail;
32527 }
32528 resultobj = SWIG_From_long(static_cast< long >(result));
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32536 PyObject *resultobj = 0;
32537 wxWindow *arg1 = (wxWindow *) 0 ;
32538 int arg2 ;
32539 bool result;
32540 void *argp1 = 0 ;
32541 int res1 = 0 ;
32542 int val2 ;
32543 int ecode2 = 0 ;
32544 PyObject * obj0 = 0 ;
32545 PyObject * obj1 = 0 ;
32546 char * kwnames[] = {
32547 (char *) "self",(char *) "flag", NULL
32548 };
32549
32550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32552 if (!SWIG_IsOK(res1)) {
32553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32554 }
32555 arg1 = reinterpret_cast< wxWindow * >(argp1);
32556 ecode2 = SWIG_AsVal_int(obj1, &val2);
32557 if (!SWIG_IsOK(ecode2)) {
32558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32559 }
32560 arg2 = static_cast< int >(val2);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
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_IsRetained(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_IsRetained" "', 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)->IsRetained();
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_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32607 PyObject *resultobj = 0;
32608 wxWindow *arg1 = (wxWindow *) 0 ;
32609 long arg2 ;
32610 void *argp1 = 0 ;
32611 int res1 = 0 ;
32612 long val2 ;
32613 int ecode2 = 0 ;
32614 PyObject * obj0 = 0 ;
32615 PyObject * obj1 = 0 ;
32616 char * kwnames[] = {
32617 (char *) "self",(char *) "exStyle", NULL
32618 };
32619
32620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32622 if (!SWIG_IsOK(res1)) {
32623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32624 }
32625 arg1 = reinterpret_cast< wxWindow * >(argp1);
32626 ecode2 = SWIG_AsVal_long(obj1, &val2);
32627 if (!SWIG_IsOK(ecode2)) {
32628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32629 }
32630 arg2 = static_cast< long >(val2);
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 (arg1)->SetExtraStyle(arg2);
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 resultobj = SWIG_Py_Void();
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 long result;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 PyObject *swig_obj[1] ;
32651
32652 if (!args) SWIG_fail;
32653 swig_obj[0] = args;
32654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32655 if (!SWIG_IsOK(res1)) {
32656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32657 }
32658 arg1 = reinterpret_cast< wxWindow * >(argp1);
32659 {
32660 PyThreadState* __tstate = wxPyBeginAllowThreads();
32661 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32662 wxPyEndAllowThreads(__tstate);
32663 if (PyErr_Occurred()) SWIG_fail;
32664 }
32665 resultobj = SWIG_From_long(static_cast< long >(result));
32666 return resultobj;
32667 fail:
32668 return NULL;
32669 }
32670
32671
32672 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32673 PyObject *resultobj = 0;
32674 wxWindow *arg1 = (wxWindow *) 0 ;
32675 bool arg2 = (bool) true ;
32676 void *argp1 = 0 ;
32677 int res1 = 0 ;
32678 bool val2 ;
32679 int ecode2 = 0 ;
32680 PyObject * obj0 = 0 ;
32681 PyObject * obj1 = 0 ;
32682 char * kwnames[] = {
32683 (char *) "self",(char *) "modal", NULL
32684 };
32685
32686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32688 if (!SWIG_IsOK(res1)) {
32689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32690 }
32691 arg1 = reinterpret_cast< wxWindow * >(argp1);
32692 if (obj1) {
32693 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32694 if (!SWIG_IsOK(ecode2)) {
32695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32696 }
32697 arg2 = static_cast< bool >(val2);
32698 }
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 (arg1)->MakeModal(arg2);
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_Py_Void();
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32713 PyObject *resultobj = 0;
32714 wxWindow *arg1 = (wxWindow *) 0 ;
32715 bool arg2 ;
32716 void *argp1 = 0 ;
32717 int res1 = 0 ;
32718 bool val2 ;
32719 int ecode2 = 0 ;
32720 PyObject * obj0 = 0 ;
32721 PyObject * obj1 = 0 ;
32722 char * kwnames[] = {
32723 (char *) "self",(char *) "enableTheme", NULL
32724 };
32725
32726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32728 if (!SWIG_IsOK(res1)) {
32729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32730 }
32731 arg1 = reinterpret_cast< wxWindow * >(argp1);
32732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32733 if (!SWIG_IsOK(ecode2)) {
32734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32735 }
32736 arg2 = static_cast< bool >(val2);
32737 {
32738 PyThreadState* __tstate = wxPyBeginAllowThreads();
32739 (arg1)->SetThemeEnabled(arg2);
32740 wxPyEndAllowThreads(__tstate);
32741 if (PyErr_Occurred()) SWIG_fail;
32742 }
32743 resultobj = SWIG_Py_Void();
32744 return resultobj;
32745 fail:
32746 return NULL;
32747 }
32748
32749
32750 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32751 PyObject *resultobj = 0;
32752 wxWindow *arg1 = (wxWindow *) 0 ;
32753 bool result;
32754 void *argp1 = 0 ;
32755 int res1 = 0 ;
32756 PyObject *swig_obj[1] ;
32757
32758 if (!args) SWIG_fail;
32759 swig_obj[0] = args;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32763 }
32764 arg1 = reinterpret_cast< wxWindow * >(argp1);
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 {
32772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32773 }
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32792 }
32793 arg1 = reinterpret_cast< wxWindow * >(argp1);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 (arg1)->SetFocus();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 resultobj = SWIG_Py_Void();
32801 return resultobj;
32802 fail:
32803 return NULL;
32804 }
32805
32806
32807 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32808 PyObject *resultobj = 0;
32809 wxWindow *arg1 = (wxWindow *) 0 ;
32810 void *argp1 = 0 ;
32811 int res1 = 0 ;
32812 PyObject *swig_obj[1] ;
32813
32814 if (!args) SWIG_fail;
32815 swig_obj[0] = args;
32816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32817 if (!SWIG_IsOK(res1)) {
32818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32819 }
32820 arg1 = reinterpret_cast< wxWindow * >(argp1);
32821 {
32822 PyThreadState* __tstate = wxPyBeginAllowThreads();
32823 (arg1)->SetFocusFromKbd();
32824 wxPyEndAllowThreads(__tstate);
32825 if (PyErr_Occurred()) SWIG_fail;
32826 }
32827 resultobj = SWIG_Py_Void();
32828 return resultobj;
32829 fail:
32830 return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32835 PyObject *resultobj = 0;
32836 wxWindow *result = 0 ;
32837
32838 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32839 {
32840 if (!wxPyCheckForApp()) SWIG_fail;
32841 PyThreadState* __tstate = wxPyBeginAllowThreads();
32842 result = (wxWindow *)wxWindow::FindFocus();
32843 wxPyEndAllowThreads(__tstate);
32844 if (PyErr_Occurred()) SWIG_fail;
32845 }
32846 {
32847 resultobj = wxPyMake_wxObject(result, 0);
32848 }
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32856 PyObject *resultobj = 0;
32857 wxWindow *arg1 = (wxWindow *) 0 ;
32858 bool result;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 PyObject *swig_obj[1] ;
32862
32863 if (!args) SWIG_fail;
32864 swig_obj[0] = args;
32865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32866 if (!SWIG_IsOK(res1)) {
32867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32868 }
32869 arg1 = reinterpret_cast< wxWindow * >(argp1);
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 {
32877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32878 }
32879 return resultobj;
32880 fail:
32881 return NULL;
32882 }
32883
32884
32885 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32886 PyObject *resultobj = 0;
32887 wxWindow *arg1 = (wxWindow *) 0 ;
32888 bool result;
32889 void *argp1 = 0 ;
32890 int res1 = 0 ;
32891 PyObject *swig_obj[1] ;
32892
32893 if (!args) SWIG_fail;
32894 swig_obj[0] = args;
32895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32896 if (!SWIG_IsOK(res1)) {
32897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32898 }
32899 arg1 = reinterpret_cast< wxWindow * >(argp1);
32900 {
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 {
32907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32908 }
32909 return resultobj;
32910 fail:
32911 return NULL;
32912 }
32913
32914
32915 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32916 PyObject *resultobj = 0;
32917 wxWindow *arg1 = (wxWindow *) 0 ;
32918 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32919 bool result;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 int val2 ;
32923 int ecode2 = 0 ;
32924 PyObject * obj0 = 0 ;
32925 PyObject * obj1 = 0 ;
32926 char * kwnames[] = {
32927 (char *) "self",(char *) "flags", NULL
32928 };
32929
32930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32932 if (!SWIG_IsOK(res1)) {
32933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32934 }
32935 arg1 = reinterpret_cast< wxWindow * >(argp1);
32936 if (obj1) {
32937 ecode2 = SWIG_AsVal_int(obj1, &val2);
32938 if (!SWIG_IsOK(ecode2)) {
32939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32940 }
32941 arg2 = static_cast< int >(val2);
32942 }
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 result = (bool)(arg1)->Navigate(arg2);
32946 wxPyEndAllowThreads(__tstate);
32947 if (PyErr_Occurred()) SWIG_fail;
32948 }
32949 {
32950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32951 }
32952 return resultobj;
32953 fail:
32954 return NULL;
32955 }
32956
32957
32958 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32959 PyObject *resultobj = 0;
32960 wxWindow *arg1 = (wxWindow *) 0 ;
32961 wxWindow *arg2 = (wxWindow *) 0 ;
32962 void *argp1 = 0 ;
32963 int res1 = 0 ;
32964 void *argp2 = 0 ;
32965 int res2 = 0 ;
32966 PyObject * obj0 = 0 ;
32967 PyObject * obj1 = 0 ;
32968 char * kwnames[] = {
32969 (char *) "self",(char *) "win", NULL
32970 };
32971
32972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32974 if (!SWIG_IsOK(res1)) {
32975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32976 }
32977 arg1 = reinterpret_cast< wxWindow * >(argp1);
32978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32979 if (!SWIG_IsOK(res2)) {
32980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32981 }
32982 arg2 = reinterpret_cast< wxWindow * >(argp2);
32983 {
32984 PyThreadState* __tstate = wxPyBeginAllowThreads();
32985 (arg1)->MoveAfterInTabOrder(arg2);
32986 wxPyEndAllowThreads(__tstate);
32987 if (PyErr_Occurred()) SWIG_fail;
32988 }
32989 resultobj = SWIG_Py_Void();
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 wxWindow *arg2 = (wxWindow *) 0 ;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 void *argp2 = 0 ;
33003 int res2 = 0 ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 char * kwnames[] = {
33007 (char *) "self",(char *) "win", NULL
33008 };
33009
33010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33014 }
33015 arg1 = reinterpret_cast< wxWindow * >(argp1);
33016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33017 if (!SWIG_IsOK(res2)) {
33018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33019 }
33020 arg2 = reinterpret_cast< wxWindow * >(argp2);
33021 {
33022 PyThreadState* __tstate = wxPyBeginAllowThreads();
33023 (arg1)->MoveBeforeInTabOrder(arg2);
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 resultobj = SWIG_Py_Void();
33028 return resultobj;
33029 fail:
33030 return NULL;
33031 }
33032
33033
33034 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33035 PyObject *resultobj = 0;
33036 wxWindow *arg1 = (wxWindow *) 0 ;
33037 PyObject *result = 0 ;
33038 void *argp1 = 0 ;
33039 int res1 = 0 ;
33040 PyObject *swig_obj[1] ;
33041
33042 if (!args) SWIG_fail;
33043 swig_obj[0] = args;
33044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33045 if (!SWIG_IsOK(res1)) {
33046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33047 }
33048 arg1 = reinterpret_cast< wxWindow * >(argp1);
33049 {
33050 PyThreadState* __tstate = wxPyBeginAllowThreads();
33051 result = (PyObject *)wxWindow_GetChildren(arg1);
33052 wxPyEndAllowThreads(__tstate);
33053 if (PyErr_Occurred()) SWIG_fail;
33054 }
33055 resultobj = result;
33056 return resultobj;
33057 fail:
33058 return NULL;
33059 }
33060
33061
33062 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33063 PyObject *resultobj = 0;
33064 wxWindow *arg1 = (wxWindow *) 0 ;
33065 wxWindow *result = 0 ;
33066 void *argp1 = 0 ;
33067 int res1 = 0 ;
33068 PyObject *swig_obj[1] ;
33069
33070 if (!args) SWIG_fail;
33071 swig_obj[0] = args;
33072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33073 if (!SWIG_IsOK(res1)) {
33074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33075 }
33076 arg1 = reinterpret_cast< wxWindow * >(argp1);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 {
33084 resultobj = wxPyMake_wxObject(result, 0);
33085 }
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33093 PyObject *resultobj = 0;
33094 wxWindow *arg1 = (wxWindow *) 0 ;
33095 wxWindow *result = 0 ;
33096 void *argp1 = 0 ;
33097 int res1 = 0 ;
33098 PyObject *swig_obj[1] ;
33099
33100 if (!args) SWIG_fail;
33101 swig_obj[0] = args;
33102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33103 if (!SWIG_IsOK(res1)) {
33104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33105 }
33106 arg1 = reinterpret_cast< wxWindow * >(argp1);
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = wxPyMake_wxObject(result, 0);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33123 PyObject *resultobj = 0;
33124 wxWindow *arg1 = (wxWindow *) 0 ;
33125 bool result;
33126 void *argp1 = 0 ;
33127 int res1 = 0 ;
33128 PyObject *swig_obj[1] ;
33129
33130 if (!args) SWIG_fail;
33131 swig_obj[0] = args;
33132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33133 if (!SWIG_IsOK(res1)) {
33134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 {
33144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33145 }
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 wxWindow *arg2 = (wxWindow *) 0 ;
33156 bool result;
33157 void *argp1 = 0 ;
33158 int res1 = 0 ;
33159 void *argp2 = 0 ;
33160 int res2 = 0 ;
33161 PyObject * obj0 = 0 ;
33162 PyObject * obj1 = 0 ;
33163 char * kwnames[] = {
33164 (char *) "self",(char *) "newParent", NULL
33165 };
33166
33167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33169 if (!SWIG_IsOK(res1)) {
33170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33171 }
33172 arg1 = reinterpret_cast< wxWindow * >(argp1);
33173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33174 if (!SWIG_IsOK(res2)) {
33175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33176 }
33177 arg2 = reinterpret_cast< wxWindow * >(argp2);
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 result = (bool)(arg1)->Reparent(arg2);
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 {
33185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33186 }
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33194 PyObject *resultobj = 0;
33195 wxWindow *arg1 = (wxWindow *) 0 ;
33196 wxWindow *arg2 = (wxWindow *) 0 ;
33197 void *argp1 = 0 ;
33198 int res1 = 0 ;
33199 void *argp2 = 0 ;
33200 int res2 = 0 ;
33201 PyObject * obj0 = 0 ;
33202 PyObject * obj1 = 0 ;
33203 char * kwnames[] = {
33204 (char *) "self",(char *) "child", NULL
33205 };
33206
33207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33209 if (!SWIG_IsOK(res1)) {
33210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33211 }
33212 arg1 = reinterpret_cast< wxWindow * >(argp1);
33213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33214 if (!SWIG_IsOK(res2)) {
33215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33216 }
33217 arg2 = reinterpret_cast< wxWindow * >(argp2);
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 (arg1)->AddChild(arg2);
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 resultobj = SWIG_Py_Void();
33225 return resultobj;
33226 fail:
33227 return NULL;
33228 }
33229
33230
33231 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33232 PyObject *resultobj = 0;
33233 wxWindow *arg1 = (wxWindow *) 0 ;
33234 wxWindow *arg2 = (wxWindow *) 0 ;
33235 void *argp1 = 0 ;
33236 int res1 = 0 ;
33237 void *argp2 = 0 ;
33238 int res2 = 0 ;
33239 PyObject * obj0 = 0 ;
33240 PyObject * obj1 = 0 ;
33241 char * kwnames[] = {
33242 (char *) "self",(char *) "child", NULL
33243 };
33244
33245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33247 if (!SWIG_IsOK(res1)) {
33248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33249 }
33250 arg1 = reinterpret_cast< wxWindow * >(argp1);
33251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33252 if (!SWIG_IsOK(res2)) {
33253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33254 }
33255 arg2 = reinterpret_cast< wxWindow * >(argp2);
33256 {
33257 PyThreadState* __tstate = wxPyBeginAllowThreads();
33258 (arg1)->RemoveChild(arg2);
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 resultobj = SWIG_Py_Void();
33263 return resultobj;
33264 fail:
33265 return NULL;
33266 }
33267
33268
33269 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33270 PyObject *resultobj = 0;
33271 wxWindow *arg1 = (wxWindow *) 0 ;
33272 bool arg2 ;
33273 void *argp1 = 0 ;
33274 int res1 = 0 ;
33275 bool val2 ;
33276 int ecode2 = 0 ;
33277 PyObject * obj0 = 0 ;
33278 PyObject * obj1 = 0 ;
33279 char * kwnames[] = {
33280 (char *) "self",(char *) "on", NULL
33281 };
33282
33283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33285 if (!SWIG_IsOK(res1)) {
33286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33287 }
33288 arg1 = reinterpret_cast< wxWindow * >(argp1);
33289 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33290 if (!SWIG_IsOK(ecode2)) {
33291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33292 }
33293 arg2 = static_cast< bool >(val2);
33294 {
33295 PyThreadState* __tstate = wxPyBeginAllowThreads();
33296 wxWindow_SetDoubleBuffered(arg1,arg2);
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 resultobj = SWIG_Py_Void();
33301 return resultobj;
33302 fail:
33303 return NULL;
33304 }
33305
33306
33307 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33308 PyObject *resultobj = 0;
33309 wxWindow *arg1 = (wxWindow *) 0 ;
33310 long arg2 ;
33311 wxWindow *result = 0 ;
33312 void *argp1 = 0 ;
33313 int res1 = 0 ;
33314 long val2 ;
33315 int ecode2 = 0 ;
33316 PyObject * obj0 = 0 ;
33317 PyObject * obj1 = 0 ;
33318 char * kwnames[] = {
33319 (char *) "self",(char *) "winid", NULL
33320 };
33321
33322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33324 if (!SWIG_IsOK(res1)) {
33325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33326 }
33327 arg1 = reinterpret_cast< wxWindow * >(argp1);
33328 ecode2 = SWIG_AsVal_long(obj1, &val2);
33329 if (!SWIG_IsOK(ecode2)) {
33330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33331 }
33332 arg2 = static_cast< long >(val2);
33333 {
33334 PyThreadState* __tstate = wxPyBeginAllowThreads();
33335 result = (wxWindow *)(arg1)->FindWindow(arg2);
33336 wxPyEndAllowThreads(__tstate);
33337 if (PyErr_Occurred()) SWIG_fail;
33338 }
33339 {
33340 resultobj = wxPyMake_wxObject(result, 0);
33341 }
33342 return resultobj;
33343 fail:
33344 return NULL;
33345 }
33346
33347
33348 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33349 PyObject *resultobj = 0;
33350 wxWindow *arg1 = (wxWindow *) 0 ;
33351 wxString *arg2 = 0 ;
33352 wxWindow *result = 0 ;
33353 void *argp1 = 0 ;
33354 int res1 = 0 ;
33355 bool temp2 = false ;
33356 PyObject * obj0 = 0 ;
33357 PyObject * obj1 = 0 ;
33358 char * kwnames[] = {
33359 (char *) "self",(char *) "name", NULL
33360 };
33361
33362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33364 if (!SWIG_IsOK(res1)) {
33365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33366 }
33367 arg1 = reinterpret_cast< wxWindow * >(argp1);
33368 {
33369 arg2 = wxString_in_helper(obj1);
33370 if (arg2 == NULL) SWIG_fail;
33371 temp2 = true;
33372 }
33373 {
33374 PyThreadState* __tstate = wxPyBeginAllowThreads();
33375 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33376 wxPyEndAllowThreads(__tstate);
33377 if (PyErr_Occurred()) SWIG_fail;
33378 }
33379 {
33380 resultobj = wxPyMake_wxObject(result, 0);
33381 }
33382 {
33383 if (temp2)
33384 delete arg2;
33385 }
33386 return resultobj;
33387 fail:
33388 {
33389 if (temp2)
33390 delete arg2;
33391 }
33392 return NULL;
33393 }
33394
33395
33396 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33397 PyObject *resultobj = 0;
33398 wxWindow *arg1 = (wxWindow *) 0 ;
33399 wxEvtHandler *result = 0 ;
33400 void *argp1 = 0 ;
33401 int res1 = 0 ;
33402 PyObject *swig_obj[1] ;
33403
33404 if (!args) SWIG_fail;
33405 swig_obj[0] = args;
33406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33407 if (!SWIG_IsOK(res1)) {
33408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33409 }
33410 arg1 = reinterpret_cast< wxWindow * >(argp1);
33411 {
33412 PyThreadState* __tstate = wxPyBeginAllowThreads();
33413 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33414 wxPyEndAllowThreads(__tstate);
33415 if (PyErr_Occurred()) SWIG_fail;
33416 }
33417 {
33418 resultobj = wxPyMake_wxObject(result, 0);
33419 }
33420 return resultobj;
33421 fail:
33422 return NULL;
33423 }
33424
33425
33426 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33427 PyObject *resultobj = 0;
33428 wxWindow *arg1 = (wxWindow *) 0 ;
33429 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33430 void *argp1 = 0 ;
33431 int res1 = 0 ;
33432 void *argp2 = 0 ;
33433 int res2 = 0 ;
33434 PyObject * obj0 = 0 ;
33435 PyObject * obj1 = 0 ;
33436 char * kwnames[] = {
33437 (char *) "self",(char *) "handler", NULL
33438 };
33439
33440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33442 if (!SWIG_IsOK(res1)) {
33443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33444 }
33445 arg1 = reinterpret_cast< wxWindow * >(argp1);
33446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33447 if (!SWIG_IsOK(res2)) {
33448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33449 }
33450 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33451 {
33452 PyThreadState* __tstate = wxPyBeginAllowThreads();
33453 (arg1)->SetEventHandler(arg2);
33454 wxPyEndAllowThreads(__tstate);
33455 if (PyErr_Occurred()) SWIG_fail;
33456 }
33457 resultobj = SWIG_Py_Void();
33458 return resultobj;
33459 fail:
33460 return NULL;
33461 }
33462
33463
33464 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33465 PyObject *resultobj = 0;
33466 wxWindow *arg1 = (wxWindow *) 0 ;
33467 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33468 void *argp1 = 0 ;
33469 int res1 = 0 ;
33470 void *argp2 = 0 ;
33471 int res2 = 0 ;
33472 PyObject * obj0 = 0 ;
33473 PyObject * obj1 = 0 ;
33474 char * kwnames[] = {
33475 (char *) "self",(char *) "handler", NULL
33476 };
33477
33478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33482 }
33483 arg1 = reinterpret_cast< wxWindow * >(argp1);
33484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33485 if (!SWIG_IsOK(res2)) {
33486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33487 }
33488 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 (arg1)->PushEventHandler(arg2);
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = SWIG_Py_Void();
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33503 PyObject *resultobj = 0;
33504 wxWindow *arg1 = (wxWindow *) 0 ;
33505 bool arg2 = (bool) false ;
33506 wxEvtHandler *result = 0 ;
33507 void *argp1 = 0 ;
33508 int res1 = 0 ;
33509 bool val2 ;
33510 int ecode2 = 0 ;
33511 PyObject * obj0 = 0 ;
33512 PyObject * obj1 = 0 ;
33513 char * kwnames[] = {
33514 (char *) "self",(char *) "deleteHandler", NULL
33515 };
33516
33517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33519 if (!SWIG_IsOK(res1)) {
33520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33521 }
33522 arg1 = reinterpret_cast< wxWindow * >(argp1);
33523 if (obj1) {
33524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33525 if (!SWIG_IsOK(ecode2)) {
33526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33527 }
33528 arg2 = static_cast< bool >(val2);
33529 }
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 {
33537 resultobj = wxPyMake_wxObject(result, 0);
33538 }
33539 return resultobj;
33540 fail:
33541 return NULL;
33542 }
33543
33544
33545 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33546 PyObject *resultobj = 0;
33547 wxWindow *arg1 = (wxWindow *) 0 ;
33548 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33549 bool result;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 void *argp2 = 0 ;
33553 int res2 = 0 ;
33554 PyObject * obj0 = 0 ;
33555 PyObject * obj1 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "handler", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33564 }
33565 arg1 = reinterpret_cast< wxWindow * >(argp1);
33566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33567 if (!SWIG_IsOK(res2)) {
33568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33569 }
33570 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33571 {
33572 PyThreadState* __tstate = wxPyBeginAllowThreads();
33573 result = (bool)(arg1)->RemoveEventHandler(arg2);
33574 wxPyEndAllowThreads(__tstate);
33575 if (PyErr_Occurred()) SWIG_fail;
33576 }
33577 {
33578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33579 }
33580 return resultobj;
33581 fail:
33582 return NULL;
33583 }
33584
33585
33586 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33587 PyObject *resultobj = 0;
33588 wxWindow *arg1 = (wxWindow *) 0 ;
33589 wxValidator *arg2 = 0 ;
33590 void *argp1 = 0 ;
33591 int res1 = 0 ;
33592 void *argp2 = 0 ;
33593 int res2 = 0 ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 char * kwnames[] = {
33597 (char *) "self",(char *) "validator", NULL
33598 };
33599
33600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33602 if (!SWIG_IsOK(res1)) {
33603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33604 }
33605 arg1 = reinterpret_cast< wxWindow * >(argp1);
33606 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33607 if (!SWIG_IsOK(res2)) {
33608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33609 }
33610 if (!argp2) {
33611 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33612 }
33613 arg2 = reinterpret_cast< wxValidator * >(argp2);
33614 {
33615 PyThreadState* __tstate = wxPyBeginAllowThreads();
33616 (arg1)->SetValidator((wxValidator const &)*arg2);
33617 wxPyEndAllowThreads(__tstate);
33618 if (PyErr_Occurred()) SWIG_fail;
33619 }
33620 resultobj = SWIG_Py_Void();
33621 return resultobj;
33622 fail:
33623 return NULL;
33624 }
33625
33626
33627 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33628 PyObject *resultobj = 0;
33629 wxWindow *arg1 = (wxWindow *) 0 ;
33630 wxValidator *result = 0 ;
33631 void *argp1 = 0 ;
33632 int res1 = 0 ;
33633 PyObject *swig_obj[1] ;
33634
33635 if (!args) SWIG_fail;
33636 swig_obj[0] = args;
33637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33638 if (!SWIG_IsOK(res1)) {
33639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33640 }
33641 arg1 = reinterpret_cast< wxWindow * >(argp1);
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxValidator *)(arg1)->GetValidator();
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 {
33649 resultobj = wxPyMake_wxObject(result, (bool)0);
33650 }
33651 return resultobj;
33652 fail:
33653 return NULL;
33654 }
33655
33656
33657 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33658 PyObject *resultobj = 0;
33659 wxWindow *arg1 = (wxWindow *) 0 ;
33660 bool result;
33661 void *argp1 = 0 ;
33662 int res1 = 0 ;
33663 PyObject *swig_obj[1] ;
33664
33665 if (!args) SWIG_fail;
33666 swig_obj[0] = args;
33667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33668 if (!SWIG_IsOK(res1)) {
33669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33670 }
33671 arg1 = reinterpret_cast< wxWindow * >(argp1);
33672 {
33673 PyThreadState* __tstate = wxPyBeginAllowThreads();
33674 result = (bool)(arg1)->Validate();
33675 wxPyEndAllowThreads(__tstate);
33676 if (PyErr_Occurred()) SWIG_fail;
33677 }
33678 {
33679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33680 }
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33688 PyObject *resultobj = 0;
33689 wxWindow *arg1 = (wxWindow *) 0 ;
33690 bool result;
33691 void *argp1 = 0 ;
33692 int res1 = 0 ;
33693 PyObject *swig_obj[1] ;
33694
33695 if (!args) SWIG_fail;
33696 swig_obj[0] = args;
33697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33698 if (!SWIG_IsOK(res1)) {
33699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33700 }
33701 arg1 = reinterpret_cast< wxWindow * >(argp1);
33702 {
33703 PyThreadState* __tstate = wxPyBeginAllowThreads();
33704 result = (bool)(arg1)->TransferDataToWindow();
33705 wxPyEndAllowThreads(__tstate);
33706 if (PyErr_Occurred()) SWIG_fail;
33707 }
33708 {
33709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33710 }
33711 return resultobj;
33712 fail:
33713 return NULL;
33714 }
33715
33716
33717 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33718 PyObject *resultobj = 0;
33719 wxWindow *arg1 = (wxWindow *) 0 ;
33720 bool result;
33721 void *argp1 = 0 ;
33722 int res1 = 0 ;
33723 PyObject *swig_obj[1] ;
33724
33725 if (!args) SWIG_fail;
33726 swig_obj[0] = args;
33727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33728 if (!SWIG_IsOK(res1)) {
33729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33730 }
33731 arg1 = reinterpret_cast< wxWindow * >(argp1);
33732 {
33733 PyThreadState* __tstate = wxPyBeginAllowThreads();
33734 result = (bool)(arg1)->TransferDataFromWindow();
33735 wxPyEndAllowThreads(__tstate);
33736 if (PyErr_Occurred()) SWIG_fail;
33737 }
33738 {
33739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33740 }
33741 return resultobj;
33742 fail:
33743 return NULL;
33744 }
33745
33746
33747 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33748 PyObject *resultobj = 0;
33749 wxWindow *arg1 = (wxWindow *) 0 ;
33750 void *argp1 = 0 ;
33751 int res1 = 0 ;
33752 PyObject *swig_obj[1] ;
33753
33754 if (!args) SWIG_fail;
33755 swig_obj[0] = args;
33756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33757 if (!SWIG_IsOK(res1)) {
33758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33759 }
33760 arg1 = reinterpret_cast< wxWindow * >(argp1);
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 (arg1)->InitDialog();
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 resultobj = SWIG_Py_Void();
33768 return resultobj;
33769 fail:
33770 return NULL;
33771 }
33772
33773
33774 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33775 PyObject *resultobj = 0;
33776 wxWindow *arg1 = (wxWindow *) 0 ;
33777 wxAcceleratorTable *arg2 = 0 ;
33778 void *argp1 = 0 ;
33779 int res1 = 0 ;
33780 void *argp2 = 0 ;
33781 int res2 = 0 ;
33782 PyObject * obj0 = 0 ;
33783 PyObject * obj1 = 0 ;
33784 char * kwnames[] = {
33785 (char *) "self",(char *) "accel", NULL
33786 };
33787
33788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33790 if (!SWIG_IsOK(res1)) {
33791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33792 }
33793 arg1 = reinterpret_cast< wxWindow * >(argp1);
33794 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33795 if (!SWIG_IsOK(res2)) {
33796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33797 }
33798 if (!argp2) {
33799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33800 }
33801 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 resultobj = SWIG_Py_Void();
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33816 PyObject *resultobj = 0;
33817 wxWindow *arg1 = (wxWindow *) 0 ;
33818 wxAcceleratorTable *result = 0 ;
33819 void *argp1 = 0 ;
33820 int res1 = 0 ;
33821 PyObject *swig_obj[1] ;
33822
33823 if (!args) SWIG_fail;
33824 swig_obj[0] = args;
33825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33826 if (!SWIG_IsOK(res1)) {
33827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33828 }
33829 arg1 = reinterpret_cast< wxWindow * >(argp1);
33830 {
33831 PyThreadState* __tstate = wxPyBeginAllowThreads();
33832 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33833 wxPyEndAllowThreads(__tstate);
33834 if (PyErr_Occurred()) SWIG_fail;
33835 }
33836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33837 return resultobj;
33838 fail:
33839 return NULL;
33840 }
33841
33842
33843 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33844 PyObject *resultobj = 0;
33845 wxWindow *arg1 = (wxWindow *) 0 ;
33846 int arg2 ;
33847 int arg3 ;
33848 int arg4 ;
33849 bool result;
33850 void *argp1 = 0 ;
33851 int res1 = 0 ;
33852 int val2 ;
33853 int ecode2 = 0 ;
33854 int val3 ;
33855 int ecode3 = 0 ;
33856 int val4 ;
33857 int ecode4 = 0 ;
33858 PyObject * obj0 = 0 ;
33859 PyObject * obj1 = 0 ;
33860 PyObject * obj2 = 0 ;
33861 PyObject * obj3 = 0 ;
33862 char * kwnames[] = {
33863 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33864 };
33865
33866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33868 if (!SWIG_IsOK(res1)) {
33869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33870 }
33871 arg1 = reinterpret_cast< wxWindow * >(argp1);
33872 ecode2 = SWIG_AsVal_int(obj1, &val2);
33873 if (!SWIG_IsOK(ecode2)) {
33874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33875 }
33876 arg2 = static_cast< int >(val2);
33877 ecode3 = SWIG_AsVal_int(obj2, &val3);
33878 if (!SWIG_IsOK(ecode3)) {
33879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33880 }
33881 arg3 = static_cast< int >(val3);
33882 ecode4 = SWIG_AsVal_int(obj3, &val4);
33883 if (!SWIG_IsOK(ecode4)) {
33884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33885 }
33886 arg4 = static_cast< int >(val4);
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33890 wxPyEndAllowThreads(__tstate);
33891 if (PyErr_Occurred()) SWIG_fail;
33892 }
33893 {
33894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33895 }
33896 return resultobj;
33897 fail:
33898 return NULL;
33899 }
33900
33901
33902 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33903 PyObject *resultobj = 0;
33904 wxWindow *arg1 = (wxWindow *) 0 ;
33905 int arg2 ;
33906 bool result;
33907 void *argp1 = 0 ;
33908 int res1 = 0 ;
33909 int val2 ;
33910 int ecode2 = 0 ;
33911 PyObject * obj0 = 0 ;
33912 PyObject * obj1 = 0 ;
33913 char * kwnames[] = {
33914 (char *) "self",(char *) "hotkeyId", NULL
33915 };
33916
33917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33919 if (!SWIG_IsOK(res1)) {
33920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33921 }
33922 arg1 = reinterpret_cast< wxWindow * >(argp1);
33923 ecode2 = SWIG_AsVal_int(obj1, &val2);
33924 if (!SWIG_IsOK(ecode2)) {
33925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33926 }
33927 arg2 = static_cast< int >(val2);
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 {
33935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33936 }
33937 return resultobj;
33938 fail:
33939 return NULL;
33940 }
33941
33942
33943 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33944 PyObject *resultobj = 0;
33945 wxWindow *arg1 = (wxWindow *) 0 ;
33946 wxPoint *arg2 = 0 ;
33947 wxPoint result;
33948 void *argp1 = 0 ;
33949 int res1 = 0 ;
33950 wxPoint temp2 ;
33951 PyObject * obj0 = 0 ;
33952 PyObject * obj1 = 0 ;
33953 char * kwnames[] = {
33954 (char *) "self",(char *) "pt", NULL
33955 };
33956
33957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33959 if (!SWIG_IsOK(res1)) {
33960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33961 }
33962 arg1 = reinterpret_cast< wxWindow * >(argp1);
33963 {
33964 arg2 = &temp2;
33965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33966 }
33967 {
33968 PyThreadState* __tstate = wxPyBeginAllowThreads();
33969 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33970 wxPyEndAllowThreads(__tstate);
33971 if (PyErr_Occurred()) SWIG_fail;
33972 }
33973 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj = 0;
33982 wxWindow *arg1 = (wxWindow *) 0 ;
33983 wxSize *arg2 = 0 ;
33984 wxSize result;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 wxSize temp2 ;
33988 PyObject * obj0 = 0 ;
33989 PyObject * obj1 = 0 ;
33990 char * kwnames[] = {
33991 (char *) "self",(char *) "sz", NULL
33992 };
33993
33994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33996 if (!SWIG_IsOK(res1)) {
33997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33998 }
33999 arg1 = reinterpret_cast< wxWindow * >(argp1);
34000 {
34001 arg2 = &temp2;
34002 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34007 wxPyEndAllowThreads(__tstate);
34008 if (PyErr_Occurred()) SWIG_fail;
34009 }
34010 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34011 return resultobj;
34012 fail:
34013 return NULL;
34014 }
34015
34016
34017 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34018 PyObject *resultobj = 0;
34019 wxWindow *arg1 = (wxWindow *) 0 ;
34020 wxPoint *arg2 = 0 ;
34021 wxPoint result;
34022 void *argp1 = 0 ;
34023 int res1 = 0 ;
34024 wxPoint temp2 ;
34025 PyObject * obj0 = 0 ;
34026 PyObject * obj1 = 0 ;
34027 char * kwnames[] = {
34028 (char *) "self",(char *) "pt", NULL
34029 };
34030
34031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34033 if (!SWIG_IsOK(res1)) {
34034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34035 }
34036 arg1 = reinterpret_cast< wxWindow * >(argp1);
34037 {
34038 arg2 = &temp2;
34039 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34040 }
34041 {
34042 PyThreadState* __tstate = wxPyBeginAllowThreads();
34043 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34044 wxPyEndAllowThreads(__tstate);
34045 if (PyErr_Occurred()) SWIG_fail;
34046 }
34047 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34048 return resultobj;
34049 fail:
34050 return NULL;
34051 }
34052
34053
34054 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34055 PyObject *resultobj = 0;
34056 wxWindow *arg1 = (wxWindow *) 0 ;
34057 wxSize *arg2 = 0 ;
34058 wxSize result;
34059 void *argp1 = 0 ;
34060 int res1 = 0 ;
34061 wxSize temp2 ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char * kwnames[] = {
34065 (char *) "self",(char *) "sz", NULL
34066 };
34067
34068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 {
34075 arg2 = &temp2;
34076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34077 }
34078 {
34079 PyThreadState* __tstate = wxPyBeginAllowThreads();
34080 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34081 wxPyEndAllowThreads(__tstate);
34082 if (PyErr_Occurred()) SWIG_fail;
34083 }
34084 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 wxPoint *arg2 = 0 ;
34095 wxPoint result;
34096 void *argp1 = 0 ;
34097 int res1 = 0 ;
34098 wxPoint temp2 ;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char * kwnames[] = {
34102 (char *) "self",(char *) "pt", NULL
34103 };
34104
34105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34107 if (!SWIG_IsOK(res1)) {
34108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34109 }
34110 arg1 = reinterpret_cast< wxWindow * >(argp1);
34111 {
34112 arg2 = &temp2;
34113 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34114 }
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34118 wxPyEndAllowThreads(__tstate);
34119 if (PyErr_Occurred()) SWIG_fail;
34120 }
34121 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34129 PyObject *resultobj = 0;
34130 wxWindow *arg1 = (wxWindow *) 0 ;
34131 wxSize *arg2 = 0 ;
34132 wxSize result;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 wxSize temp2 ;
34136 PyObject * obj0 = 0 ;
34137 PyObject * obj1 = 0 ;
34138 char * kwnames[] = {
34139 (char *) "self",(char *) "sz", NULL
34140 };
34141
34142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34144 if (!SWIG_IsOK(res1)) {
34145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34146 }
34147 arg1 = reinterpret_cast< wxWindow * >(argp1);
34148 {
34149 arg2 = &temp2;
34150 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34151 }
34152 {
34153 PyThreadState* __tstate = wxPyBeginAllowThreads();
34154 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34155 wxPyEndAllowThreads(__tstate);
34156 if (PyErr_Occurred()) SWIG_fail;
34157 }
34158 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34159 return resultobj;
34160 fail:
34161 return NULL;
34162 }
34163
34164
34165 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34166 PyObject *resultobj = 0;
34167 wxWindow *arg1 = (wxWindow *) 0 ;
34168 int arg2 ;
34169 int arg3 ;
34170 void *argp1 = 0 ;
34171 int res1 = 0 ;
34172 int val2 ;
34173 int ecode2 = 0 ;
34174 int val3 ;
34175 int ecode3 = 0 ;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 PyObject * obj2 = 0 ;
34179 char * kwnames[] = {
34180 (char *) "self",(char *) "x",(char *) "y", NULL
34181 };
34182
34183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34185 if (!SWIG_IsOK(res1)) {
34186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34187 }
34188 arg1 = reinterpret_cast< wxWindow * >(argp1);
34189 ecode2 = SWIG_AsVal_int(obj1, &val2);
34190 if (!SWIG_IsOK(ecode2)) {
34191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34192 }
34193 arg2 = static_cast< int >(val2);
34194 ecode3 = SWIG_AsVal_int(obj2, &val3);
34195 if (!SWIG_IsOK(ecode3)) {
34196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34197 }
34198 arg3 = static_cast< int >(val3);
34199 {
34200 PyThreadState* __tstate = wxPyBeginAllowThreads();
34201 (arg1)->WarpPointer(arg2,arg3);
34202 wxPyEndAllowThreads(__tstate);
34203 if (PyErr_Occurred()) SWIG_fail;
34204 }
34205 resultobj = SWIG_Py_Void();
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34213 PyObject *resultobj = 0;
34214 wxWindow *arg1 = (wxWindow *) 0 ;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 PyObject *swig_obj[1] ;
34218
34219 if (!args) SWIG_fail;
34220 swig_obj[0] = args;
34221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34224 }
34225 arg1 = reinterpret_cast< wxWindow * >(argp1);
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 (arg1)->CaptureMouse();
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 resultobj = SWIG_Py_Void();
34233 return resultobj;
34234 fail:
34235 return NULL;
34236 }
34237
34238
34239 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34240 PyObject *resultobj = 0;
34241 wxWindow *arg1 = (wxWindow *) 0 ;
34242 void *argp1 = 0 ;
34243 int res1 = 0 ;
34244 PyObject *swig_obj[1] ;
34245
34246 if (!args) SWIG_fail;
34247 swig_obj[0] = args;
34248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34251 }
34252 arg1 = reinterpret_cast< wxWindow * >(argp1);
34253 {
34254 PyThreadState* __tstate = wxPyBeginAllowThreads();
34255 (arg1)->ReleaseMouse();
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 resultobj = SWIG_Py_Void();
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34267 PyObject *resultobj = 0;
34268 wxWindow *result = 0 ;
34269
34270 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34271 {
34272 if (!wxPyCheckForApp()) SWIG_fail;
34273 PyThreadState* __tstate = wxPyBeginAllowThreads();
34274 result = (wxWindow *)wxWindow::GetCapture();
34275 wxPyEndAllowThreads(__tstate);
34276 if (PyErr_Occurred()) SWIG_fail;
34277 }
34278 {
34279 resultobj = wxPyMake_wxObject(result, 0);
34280 }
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34288 PyObject *resultobj = 0;
34289 wxWindow *arg1 = (wxWindow *) 0 ;
34290 bool result;
34291 void *argp1 = 0 ;
34292 int res1 = 0 ;
34293 PyObject *swig_obj[1] ;
34294
34295 if (!args) SWIG_fail;
34296 swig_obj[0] = args;
34297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34298 if (!SWIG_IsOK(res1)) {
34299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34300 }
34301 arg1 = reinterpret_cast< wxWindow * >(argp1);
34302 {
34303 PyThreadState* __tstate = wxPyBeginAllowThreads();
34304 result = (bool)((wxWindow const *)arg1)->HasCapture();
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 {
34309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34310 }
34311 return resultobj;
34312 fail:
34313 return NULL;
34314 }
34315
34316
34317 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34318 PyObject *resultobj = 0;
34319 wxWindow *arg1 = (wxWindow *) 0 ;
34320 bool arg2 = (bool) true ;
34321 wxRect *arg3 = (wxRect *) NULL ;
34322 void *argp1 = 0 ;
34323 int res1 = 0 ;
34324 bool val2 ;
34325 int ecode2 = 0 ;
34326 void *argp3 = 0 ;
34327 int res3 = 0 ;
34328 PyObject * obj0 = 0 ;
34329 PyObject * obj1 = 0 ;
34330 PyObject * obj2 = 0 ;
34331 char * kwnames[] = {
34332 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34333 };
34334
34335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34339 }
34340 arg1 = reinterpret_cast< wxWindow * >(argp1);
34341 if (obj1) {
34342 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34343 if (!SWIG_IsOK(ecode2)) {
34344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34345 }
34346 arg2 = static_cast< bool >(val2);
34347 }
34348 if (obj2) {
34349 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34350 if (!SWIG_IsOK(res3)) {
34351 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34352 }
34353 arg3 = reinterpret_cast< wxRect * >(argp3);
34354 }
34355 {
34356 PyThreadState* __tstate = wxPyBeginAllowThreads();
34357 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34358 wxPyEndAllowThreads(__tstate);
34359 if (PyErr_Occurred()) SWIG_fail;
34360 }
34361 resultobj = SWIG_Py_Void();
34362 return resultobj;
34363 fail:
34364 return NULL;
34365 }
34366
34367
34368 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34369 PyObject *resultobj = 0;
34370 wxWindow *arg1 = (wxWindow *) 0 ;
34371 wxRect *arg2 = 0 ;
34372 bool arg3 = (bool) true ;
34373 void *argp1 = 0 ;
34374 int res1 = 0 ;
34375 wxRect temp2 ;
34376 bool val3 ;
34377 int ecode3 = 0 ;
34378 PyObject * obj0 = 0 ;
34379 PyObject * obj1 = 0 ;
34380 PyObject * obj2 = 0 ;
34381 char * kwnames[] = {
34382 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34383 };
34384
34385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34387 if (!SWIG_IsOK(res1)) {
34388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34389 }
34390 arg1 = reinterpret_cast< wxWindow * >(argp1);
34391 {
34392 arg2 = &temp2;
34393 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34394 }
34395 if (obj2) {
34396 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34397 if (!SWIG_IsOK(ecode3)) {
34398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34399 }
34400 arg3 = static_cast< bool >(val3);
34401 }
34402 {
34403 PyThreadState* __tstate = wxPyBeginAllowThreads();
34404 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 resultobj = SWIG_Py_Void();
34409 return resultobj;
34410 fail:
34411 return NULL;
34412 }
34413
34414
34415 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34416 PyObject *resultobj = 0;
34417 wxWindow *arg1 = (wxWindow *) 0 ;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 (arg1)->Update();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_Py_Void();
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 PyObject *swig_obj[1] ;
34448
34449 if (!args) SWIG_fail;
34450 swig_obj[0] = args;
34451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34452 if (!SWIG_IsOK(res1)) {
34453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34454 }
34455 arg1 = reinterpret_cast< wxWindow * >(argp1);
34456 {
34457 PyThreadState* __tstate = wxPyBeginAllowThreads();
34458 (arg1)->ClearBackground();
34459 wxPyEndAllowThreads(__tstate);
34460 if (PyErr_Occurred()) SWIG_fail;
34461 }
34462 resultobj = SWIG_Py_Void();
34463 return resultobj;
34464 fail:
34465 return NULL;
34466 }
34467
34468
34469 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34470 PyObject *resultobj = 0;
34471 wxWindow *arg1 = (wxWindow *) 0 ;
34472 void *argp1 = 0 ;
34473 int res1 = 0 ;
34474 PyObject *swig_obj[1] ;
34475
34476 if (!args) SWIG_fail;
34477 swig_obj[0] = args;
34478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34479 if (!SWIG_IsOK(res1)) {
34480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34481 }
34482 arg1 = reinterpret_cast< wxWindow * >(argp1);
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 (arg1)->Freeze();
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 resultobj = SWIG_Py_Void();
34490 return resultobj;
34491 fail:
34492 return NULL;
34493 }
34494
34495
34496 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34497 PyObject *resultobj = 0;
34498 wxWindow *arg1 = (wxWindow *) 0 ;
34499 void *argp1 = 0 ;
34500 int res1 = 0 ;
34501 PyObject *swig_obj[1] ;
34502
34503 if (!args) SWIG_fail;
34504 swig_obj[0] = args;
34505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34506 if (!SWIG_IsOK(res1)) {
34507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34508 }
34509 arg1 = reinterpret_cast< wxWindow * >(argp1);
34510 {
34511 PyThreadState* __tstate = wxPyBeginAllowThreads();
34512 (arg1)->Thaw();
34513 wxPyEndAllowThreads(__tstate);
34514 if (PyErr_Occurred()) SWIG_fail;
34515 }
34516 resultobj = SWIG_Py_Void();
34517 return resultobj;
34518 fail:
34519 return NULL;
34520 }
34521
34522
34523 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34524 PyObject *resultobj = 0;
34525 wxWindow *arg1 = (wxWindow *) 0 ;
34526 wxDC *arg2 = 0 ;
34527 void *argp1 = 0 ;
34528 int res1 = 0 ;
34529 void *argp2 = 0 ;
34530 int res2 = 0 ;
34531 PyObject * obj0 = 0 ;
34532 PyObject * obj1 = 0 ;
34533 char * kwnames[] = {
34534 (char *) "self",(char *) "dc", NULL
34535 };
34536
34537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34539 if (!SWIG_IsOK(res1)) {
34540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34541 }
34542 arg1 = reinterpret_cast< wxWindow * >(argp1);
34543 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34544 if (!SWIG_IsOK(res2)) {
34545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34546 }
34547 if (!argp2) {
34548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34549 }
34550 arg2 = reinterpret_cast< wxDC * >(argp2);
34551 {
34552 PyThreadState* __tstate = wxPyBeginAllowThreads();
34553 (arg1)->PrepareDC(*arg2);
34554 wxPyEndAllowThreads(__tstate);
34555 if (PyErr_Occurred()) SWIG_fail;
34556 }
34557 resultobj = SWIG_Py_Void();
34558 return resultobj;
34559 fail:
34560 return NULL;
34561 }
34562
34563
34564 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34565 PyObject *resultobj = 0;
34566 wxWindow *arg1 = (wxWindow *) 0 ;
34567 wxRegion *result = 0 ;
34568 void *argp1 = 0 ;
34569 int res1 = 0 ;
34570 PyObject *swig_obj[1] ;
34571
34572 if (!args) SWIG_fail;
34573 swig_obj[0] = args;
34574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34577 }
34578 arg1 = reinterpret_cast< wxWindow * >(argp1);
34579 {
34580 PyThreadState* __tstate = wxPyBeginAllowThreads();
34581 {
34582 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34583 result = (wxRegion *) &_result_ref;
34584 }
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 wxRect result;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 PyObject *swig_obj[1] ;
34602
34603 if (!args) SWIG_fail;
34604 swig_obj[0] = args;
34605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34606 if (!SWIG_IsOK(res1)) {
34607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34608 }
34609 arg1 = reinterpret_cast< wxWindow * >(argp1);
34610 {
34611 PyThreadState* __tstate = wxPyBeginAllowThreads();
34612 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34613 wxPyEndAllowThreads(__tstate);
34614 if (PyErr_Occurred()) SWIG_fail;
34615 }
34616 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34617 return resultobj;
34618 fail:
34619 return NULL;
34620 }
34621
34622
34623 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34624 PyObject *resultobj = 0;
34625 wxWindow *arg1 = (wxWindow *) 0 ;
34626 int arg2 ;
34627 int arg3 ;
34628 int arg4 = (int) 1 ;
34629 int arg5 = (int) 1 ;
34630 bool result;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 int val2 ;
34634 int ecode2 = 0 ;
34635 int val3 ;
34636 int ecode3 = 0 ;
34637 int val4 ;
34638 int ecode4 = 0 ;
34639 int val5 ;
34640 int ecode5 = 0 ;
34641 PyObject * obj0 = 0 ;
34642 PyObject * obj1 = 0 ;
34643 PyObject * obj2 = 0 ;
34644 PyObject * obj3 = 0 ;
34645 PyObject * obj4 = 0 ;
34646 char * kwnames[] = {
34647 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34648 };
34649
34650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34652 if (!SWIG_IsOK(res1)) {
34653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34654 }
34655 arg1 = reinterpret_cast< wxWindow * >(argp1);
34656 ecode2 = SWIG_AsVal_int(obj1, &val2);
34657 if (!SWIG_IsOK(ecode2)) {
34658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34659 }
34660 arg2 = static_cast< int >(val2);
34661 ecode3 = SWIG_AsVal_int(obj2, &val3);
34662 if (!SWIG_IsOK(ecode3)) {
34663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34664 }
34665 arg3 = static_cast< int >(val3);
34666 if (obj3) {
34667 ecode4 = SWIG_AsVal_int(obj3, &val4);
34668 if (!SWIG_IsOK(ecode4)) {
34669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34670 }
34671 arg4 = static_cast< int >(val4);
34672 }
34673 if (obj4) {
34674 ecode5 = SWIG_AsVal_int(obj4, &val5);
34675 if (!SWIG_IsOK(ecode5)) {
34676 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34677 }
34678 arg5 = static_cast< int >(val5);
34679 }
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34683 wxPyEndAllowThreads(__tstate);
34684 if (PyErr_Occurred()) SWIG_fail;
34685 }
34686 {
34687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34688 }
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj = 0;
34697 wxWindow *arg1 = (wxWindow *) 0 ;
34698 wxPoint *arg2 = 0 ;
34699 bool result;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 wxPoint temp2 ;
34703 PyObject * obj0 = 0 ;
34704 PyObject * obj1 = 0 ;
34705 char * kwnames[] = {
34706 (char *) "self",(char *) "pt", NULL
34707 };
34708
34709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34711 if (!SWIG_IsOK(res1)) {
34712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34713 }
34714 arg1 = reinterpret_cast< wxWindow * >(argp1);
34715 {
34716 arg2 = &temp2;
34717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34718 }
34719 {
34720 PyThreadState* __tstate = wxPyBeginAllowThreads();
34721 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34722 wxPyEndAllowThreads(__tstate);
34723 if (PyErr_Occurred()) SWIG_fail;
34724 }
34725 {
34726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34727 }
34728 return resultobj;
34729 fail:
34730 return NULL;
34731 }
34732
34733
34734 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34735 PyObject *resultobj = 0;
34736 wxWindow *arg1 = (wxWindow *) 0 ;
34737 wxRect *arg2 = 0 ;
34738 bool result;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 wxRect temp2 ;
34742 PyObject * obj0 = 0 ;
34743 PyObject * obj1 = 0 ;
34744 char * kwnames[] = {
34745 (char *) "self",(char *) "rect", NULL
34746 };
34747
34748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34750 if (!SWIG_IsOK(res1)) {
34751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34752 }
34753 arg1 = reinterpret_cast< wxWindow * >(argp1);
34754 {
34755 arg2 = &temp2;
34756 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34757 }
34758 {
34759 PyThreadState* __tstate = wxPyBeginAllowThreads();
34760 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34761 wxPyEndAllowThreads(__tstate);
34762 if (PyErr_Occurred()) SWIG_fail;
34763 }
34764 {
34765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34766 }
34767 return resultobj;
34768 fail:
34769 return NULL;
34770 }
34771
34772
34773 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34774 PyObject *resultobj = 0;
34775 wxWindow *arg1 = (wxWindow *) 0 ;
34776 SwigValueWrapper<wxVisualAttributes > result;
34777 void *argp1 = 0 ;
34778 int res1 = 0 ;
34779 PyObject *swig_obj[1] ;
34780
34781 if (!args) SWIG_fail;
34782 swig_obj[0] = args;
34783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34784 if (!SWIG_IsOK(res1)) {
34785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34786 }
34787 arg1 = reinterpret_cast< wxWindow * >(argp1);
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34802 PyObject *resultobj = 0;
34803 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34804 SwigValueWrapper<wxVisualAttributes > result;
34805 int val1 ;
34806 int ecode1 = 0 ;
34807 PyObject * obj0 = 0 ;
34808 char * kwnames[] = {
34809 (char *) "variant", NULL
34810 };
34811
34812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34813 if (obj0) {
34814 ecode1 = SWIG_AsVal_int(obj0, &val1);
34815 if (!SWIG_IsOK(ecode1)) {
34816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34817 }
34818 arg1 = static_cast< wxWindowVariant >(val1);
34819 }
34820 {
34821 if (!wxPyCheckForApp()) SWIG_fail;
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = wxWindow::GetClassDefaultAttributes(arg1);
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34828 return resultobj;
34829 fail:
34830 return NULL;
34831 }
34832
34833
34834 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34835 PyObject *resultobj = 0;
34836 wxWindow *arg1 = (wxWindow *) 0 ;
34837 wxColour *arg2 = 0 ;
34838 bool result;
34839 void *argp1 = 0 ;
34840 int res1 = 0 ;
34841 wxColour temp2 ;
34842 PyObject * obj0 = 0 ;
34843 PyObject * obj1 = 0 ;
34844 char * kwnames[] = {
34845 (char *) "self",(char *) "colour", NULL
34846 };
34847
34848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34850 if (!SWIG_IsOK(res1)) {
34851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34852 }
34853 arg1 = reinterpret_cast< wxWindow * >(argp1);
34854 {
34855 arg2 = &temp2;
34856 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34857 }
34858 {
34859 PyThreadState* __tstate = wxPyBeginAllowThreads();
34860 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34861 wxPyEndAllowThreads(__tstate);
34862 if (PyErr_Occurred()) SWIG_fail;
34863 }
34864 {
34865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34866 }
34867 return resultobj;
34868 fail:
34869 return NULL;
34870 }
34871
34872
34873 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34874 PyObject *resultobj = 0;
34875 wxWindow *arg1 = (wxWindow *) 0 ;
34876 wxColour *arg2 = 0 ;
34877 void *argp1 = 0 ;
34878 int res1 = 0 ;
34879 wxColour temp2 ;
34880 PyObject * obj0 = 0 ;
34881 PyObject * obj1 = 0 ;
34882 char * kwnames[] = {
34883 (char *) "self",(char *) "colour", NULL
34884 };
34885
34886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34888 if (!SWIG_IsOK(res1)) {
34889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34890 }
34891 arg1 = reinterpret_cast< wxWindow * >(argp1);
34892 {
34893 arg2 = &temp2;
34894 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34895 }
34896 {
34897 PyThreadState* __tstate = wxPyBeginAllowThreads();
34898 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34899 wxPyEndAllowThreads(__tstate);
34900 if (PyErr_Occurred()) SWIG_fail;
34901 }
34902 resultobj = SWIG_Py_Void();
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34910 PyObject *resultobj = 0;
34911 wxWindow *arg1 = (wxWindow *) 0 ;
34912 wxColour *arg2 = 0 ;
34913 bool result;
34914 void *argp1 = 0 ;
34915 int res1 = 0 ;
34916 wxColour temp2 ;
34917 PyObject * obj0 = 0 ;
34918 PyObject * obj1 = 0 ;
34919 char * kwnames[] = {
34920 (char *) "self",(char *) "colour", NULL
34921 };
34922
34923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34925 if (!SWIG_IsOK(res1)) {
34926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34927 }
34928 arg1 = reinterpret_cast< wxWindow * >(argp1);
34929 {
34930 arg2 = &temp2;
34931 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34932 }
34933 {
34934 PyThreadState* __tstate = wxPyBeginAllowThreads();
34935 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34936 wxPyEndAllowThreads(__tstate);
34937 if (PyErr_Occurred()) SWIG_fail;
34938 }
34939 {
34940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34941 }
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34949 PyObject *resultobj = 0;
34950 wxWindow *arg1 = (wxWindow *) 0 ;
34951 wxColour *arg2 = 0 ;
34952 void *argp1 = 0 ;
34953 int res1 = 0 ;
34954 wxColour temp2 ;
34955 PyObject * obj0 = 0 ;
34956 PyObject * obj1 = 0 ;
34957 char * kwnames[] = {
34958 (char *) "self",(char *) "colour", NULL
34959 };
34960
34961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34963 if (!SWIG_IsOK(res1)) {
34964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34965 }
34966 arg1 = reinterpret_cast< wxWindow * >(argp1);
34967 {
34968 arg2 = &temp2;
34969 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34970 }
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 resultobj = SWIG_Py_Void();
34978 return resultobj;
34979 fail:
34980 return NULL;
34981 }
34982
34983
34984 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34985 PyObject *resultobj = 0;
34986 wxWindow *arg1 = (wxWindow *) 0 ;
34987 wxColour result;
34988 void *argp1 = 0 ;
34989 int res1 = 0 ;
34990 PyObject *swig_obj[1] ;
34991
34992 if (!args) SWIG_fail;
34993 swig_obj[0] = args;
34994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34995 if (!SWIG_IsOK(res1)) {
34996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34997 }
34998 arg1 = reinterpret_cast< wxWindow * >(argp1);
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35013 PyObject *resultobj = 0;
35014 wxWindow *arg1 = (wxWindow *) 0 ;
35015 wxColour result;
35016 void *argp1 = 0 ;
35017 int res1 = 0 ;
35018 PyObject *swig_obj[1] ;
35019
35020 if (!args) SWIG_fail;
35021 swig_obj[0] = args;
35022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35025 }
35026 arg1 = reinterpret_cast< wxWindow * >(argp1);
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 result = ((wxWindow const *)arg1)->GetForegroundColour();
35030 wxPyEndAllowThreads(__tstate);
35031 if (PyErr_Occurred()) SWIG_fail;
35032 }
35033 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35034 return resultobj;
35035 fail:
35036 return NULL;
35037 }
35038
35039
35040 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35041 PyObject *resultobj = 0;
35042 wxWindow *arg1 = (wxWindow *) 0 ;
35043 bool result;
35044 void *argp1 = 0 ;
35045 int res1 = 0 ;
35046 PyObject *swig_obj[1] ;
35047
35048 if (!args) SWIG_fail;
35049 swig_obj[0] = args;
35050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35053 }
35054 arg1 = reinterpret_cast< wxWindow * >(argp1);
35055 {
35056 PyThreadState* __tstate = wxPyBeginAllowThreads();
35057 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35058 wxPyEndAllowThreads(__tstate);
35059 if (PyErr_Occurred()) SWIG_fail;
35060 }
35061 {
35062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35063 }
35064 return resultobj;
35065 fail:
35066 return NULL;
35067 }
35068
35069
35070 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35071 PyObject *resultobj = 0;
35072 wxWindow *arg1 = (wxWindow *) 0 ;
35073 bool result;
35074 void *argp1 = 0 ;
35075 int res1 = 0 ;
35076 PyObject *swig_obj[1] ;
35077
35078 if (!args) SWIG_fail;
35079 swig_obj[0] = args;
35080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35081 if (!SWIG_IsOK(res1)) {
35082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35083 }
35084 arg1 = reinterpret_cast< wxWindow * >(argp1);
35085 {
35086 PyThreadState* __tstate = wxPyBeginAllowThreads();
35087 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35088 wxPyEndAllowThreads(__tstate);
35089 if (PyErr_Occurred()) SWIG_fail;
35090 }
35091 {
35092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35093 }
35094 return resultobj;
35095 fail:
35096 return NULL;
35097 }
35098
35099
35100 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 wxBackgroundStyle arg2 ;
35104 bool result;
35105 void *argp1 = 0 ;
35106 int res1 = 0 ;
35107 int val2 ;
35108 int ecode2 = 0 ;
35109 PyObject * obj0 = 0 ;
35110 PyObject * obj1 = 0 ;
35111 char * kwnames[] = {
35112 (char *) "self",(char *) "style", NULL
35113 };
35114
35115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35117 if (!SWIG_IsOK(res1)) {
35118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35119 }
35120 arg1 = reinterpret_cast< wxWindow * >(argp1);
35121 ecode2 = SWIG_AsVal_int(obj1, &val2);
35122 if (!SWIG_IsOK(ecode2)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35124 }
35125 arg2 = static_cast< wxBackgroundStyle >(val2);
35126 {
35127 PyThreadState* __tstate = wxPyBeginAllowThreads();
35128 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35129 wxPyEndAllowThreads(__tstate);
35130 if (PyErr_Occurred()) SWIG_fail;
35131 }
35132 {
35133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35134 }
35135 return resultobj;
35136 fail:
35137 return NULL;
35138 }
35139
35140
35141 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35142 PyObject *resultobj = 0;
35143 wxWindow *arg1 = (wxWindow *) 0 ;
35144 wxBackgroundStyle result;
35145 void *argp1 = 0 ;
35146 int res1 = 0 ;
35147 PyObject *swig_obj[1] ;
35148
35149 if (!args) SWIG_fail;
35150 swig_obj[0] = args;
35151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35152 if (!SWIG_IsOK(res1)) {
35153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35154 }
35155 arg1 = reinterpret_cast< wxWindow * >(argp1);
35156 {
35157 PyThreadState* __tstate = wxPyBeginAllowThreads();
35158 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35159 wxPyEndAllowThreads(__tstate);
35160 if (PyErr_Occurred()) SWIG_fail;
35161 }
35162 resultobj = SWIG_From_int(static_cast< int >(result));
35163 return resultobj;
35164 fail:
35165 return NULL;
35166 }
35167
35168
35169 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35170 PyObject *resultobj = 0;
35171 wxWindow *arg1 = (wxWindow *) 0 ;
35172 bool result;
35173 void *argp1 = 0 ;
35174 int res1 = 0 ;
35175 PyObject *swig_obj[1] ;
35176
35177 if (!args) SWIG_fail;
35178 swig_obj[0] = args;
35179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35180 if (!SWIG_IsOK(res1)) {
35181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35182 }
35183 arg1 = reinterpret_cast< wxWindow * >(argp1);
35184 {
35185 PyThreadState* __tstate = wxPyBeginAllowThreads();
35186 result = (bool)(arg1)->HasTransparentBackground();
35187 wxPyEndAllowThreads(__tstate);
35188 if (PyErr_Occurred()) SWIG_fail;
35189 }
35190 {
35191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35192 }
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 wxCursor *arg2 = 0 ;
35203 bool result;
35204 void *argp1 = 0 ;
35205 int res1 = 0 ;
35206 void *argp2 = 0 ;
35207 int res2 = 0 ;
35208 PyObject * obj0 = 0 ;
35209 PyObject * obj1 = 0 ;
35210 char * kwnames[] = {
35211 (char *) "self",(char *) "cursor", NULL
35212 };
35213
35214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35216 if (!SWIG_IsOK(res1)) {
35217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35218 }
35219 arg1 = reinterpret_cast< wxWindow * >(argp1);
35220 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35221 if (!SWIG_IsOK(res2)) {
35222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35223 }
35224 if (!argp2) {
35225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35226 }
35227 arg2 = reinterpret_cast< wxCursor * >(argp2);
35228 {
35229 PyThreadState* __tstate = wxPyBeginAllowThreads();
35230 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35231 wxPyEndAllowThreads(__tstate);
35232 if (PyErr_Occurred()) SWIG_fail;
35233 }
35234 {
35235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35236 }
35237 return resultobj;
35238 fail:
35239 return NULL;
35240 }
35241
35242
35243 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35244 PyObject *resultobj = 0;
35245 wxWindow *arg1 = (wxWindow *) 0 ;
35246 wxCursor result;
35247 void *argp1 = 0 ;
35248 int res1 = 0 ;
35249 PyObject *swig_obj[1] ;
35250
35251 if (!args) SWIG_fail;
35252 swig_obj[0] = args;
35253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35254 if (!SWIG_IsOK(res1)) {
35255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35256 }
35257 arg1 = reinterpret_cast< wxWindow * >(argp1);
35258 {
35259 PyThreadState* __tstate = wxPyBeginAllowThreads();
35260 result = (arg1)->GetCursor();
35261 wxPyEndAllowThreads(__tstate);
35262 if (PyErr_Occurred()) SWIG_fail;
35263 }
35264 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35265 return resultobj;
35266 fail:
35267 return NULL;
35268 }
35269
35270
35271 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35272 PyObject *resultobj = 0;
35273 wxWindow *arg1 = (wxWindow *) 0 ;
35274 wxFont *arg2 = 0 ;
35275 bool result;
35276 void *argp1 = 0 ;
35277 int res1 = 0 ;
35278 void *argp2 = 0 ;
35279 int res2 = 0 ;
35280 PyObject * obj0 = 0 ;
35281 PyObject * obj1 = 0 ;
35282 char * kwnames[] = {
35283 (char *) "self",(char *) "font", NULL
35284 };
35285
35286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35288 if (!SWIG_IsOK(res1)) {
35289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35290 }
35291 arg1 = reinterpret_cast< wxWindow * >(argp1);
35292 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35293 if (!SWIG_IsOK(res2)) {
35294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35295 }
35296 if (!argp2) {
35297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35298 }
35299 arg2 = reinterpret_cast< wxFont * >(argp2);
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 {
35307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35308 }
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35316 PyObject *resultobj = 0;
35317 wxWindow *arg1 = (wxWindow *) 0 ;
35318 wxFont *arg2 = 0 ;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 void *argp2 = 0 ;
35322 int res2 = 0 ;
35323 PyObject * obj0 = 0 ;
35324 PyObject * obj1 = 0 ;
35325 char * kwnames[] = {
35326 (char *) "self",(char *) "font", NULL
35327 };
35328
35329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35331 if (!SWIG_IsOK(res1)) {
35332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35333 }
35334 arg1 = reinterpret_cast< wxWindow * >(argp1);
35335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35336 if (!SWIG_IsOK(res2)) {
35337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35338 }
35339 if (!argp2) {
35340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35341 }
35342 arg2 = reinterpret_cast< wxFont * >(argp2);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 (arg1)->SetOwnFont((wxFont const &)*arg2);
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 resultobj = SWIG_Py_Void();
35350 return resultobj;
35351 fail:
35352 return NULL;
35353 }
35354
35355
35356 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35357 PyObject *resultobj = 0;
35358 wxWindow *arg1 = (wxWindow *) 0 ;
35359 wxFont result;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 PyObject *swig_obj[1] ;
35363
35364 if (!args) SWIG_fail;
35365 swig_obj[0] = args;
35366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 result = (arg1)->GetFont();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 wxCaret *arg2 = (wxCaret *) 0 ;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 int res2 = 0 ;
35391 PyObject * obj0 = 0 ;
35392 PyObject * obj1 = 0 ;
35393 char * kwnames[] = {
35394 (char *) "self",(char *) "caret", NULL
35395 };
35396
35397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35399 if (!SWIG_IsOK(res1)) {
35400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35401 }
35402 arg1 = reinterpret_cast< wxWindow * >(argp1);
35403 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35404 if (!SWIG_IsOK(res2)) {
35405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35406 }
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 (arg1)->SetCaret(arg2);
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 resultobj = SWIG_Py_Void();
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35421 PyObject *resultobj = 0;
35422 wxWindow *arg1 = (wxWindow *) 0 ;
35423 wxCaret *result = 0 ;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 PyObject *swig_obj[1] ;
35427
35428 if (!args) SWIG_fail;
35429 swig_obj[0] = args;
35430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35433 }
35434 arg1 = reinterpret_cast< wxWindow * >(argp1);
35435 {
35436 PyThreadState* __tstate = wxPyBeginAllowThreads();
35437 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35438 wxPyEndAllowThreads(__tstate);
35439 if (PyErr_Occurred()) SWIG_fail;
35440 }
35441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35442 return resultobj;
35443 fail:
35444 return NULL;
35445 }
35446
35447
35448 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35449 PyObject *resultobj = 0;
35450 wxWindow *arg1 = (wxWindow *) 0 ;
35451 int result;
35452 void *argp1 = 0 ;
35453 int res1 = 0 ;
35454 PyObject *swig_obj[1] ;
35455
35456 if (!args) SWIG_fail;
35457 swig_obj[0] = args;
35458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35459 if (!SWIG_IsOK(res1)) {
35460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35461 }
35462 arg1 = reinterpret_cast< wxWindow * >(argp1);
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 resultobj = SWIG_From_int(static_cast< int >(result));
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35477 PyObject *resultobj = 0;
35478 wxWindow *arg1 = (wxWindow *) 0 ;
35479 int result;
35480 void *argp1 = 0 ;
35481 int res1 = 0 ;
35482 PyObject *swig_obj[1] ;
35483
35484 if (!args) SWIG_fail;
35485 swig_obj[0] = args;
35486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35487 if (!SWIG_IsOK(res1)) {
35488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35489 }
35490 arg1 = reinterpret_cast< wxWindow * >(argp1);
35491 {
35492 PyThreadState* __tstate = wxPyBeginAllowThreads();
35493 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 resultobj = SWIG_From_int(static_cast< int >(result));
35498 return resultobj;
35499 fail:
35500 return NULL;
35501 }
35502
35503
35504 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35505 PyObject *resultobj = 0;
35506 wxWindow *arg1 = (wxWindow *) 0 ;
35507 wxString *arg2 = 0 ;
35508 int *arg3 = (int *) 0 ;
35509 int *arg4 = (int *) 0 ;
35510 void *argp1 = 0 ;
35511 int res1 = 0 ;
35512 bool temp2 = false ;
35513 int temp3 ;
35514 int res3 = SWIG_TMPOBJ ;
35515 int temp4 ;
35516 int res4 = SWIG_TMPOBJ ;
35517 PyObject * obj0 = 0 ;
35518 PyObject * obj1 = 0 ;
35519 char * kwnames[] = {
35520 (char *) "self",(char *) "string", NULL
35521 };
35522
35523 arg3 = &temp3;
35524 arg4 = &temp4;
35525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35527 if (!SWIG_IsOK(res1)) {
35528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35529 }
35530 arg1 = reinterpret_cast< wxWindow * >(argp1);
35531 {
35532 arg2 = wxString_in_helper(obj1);
35533 if (arg2 == NULL) SWIG_fail;
35534 temp2 = true;
35535 }
35536 {
35537 PyThreadState* __tstate = wxPyBeginAllowThreads();
35538 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 resultobj = SWIG_Py_Void();
35543 if (SWIG_IsTmpObj(res3)) {
35544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35545 } else {
35546 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35548 }
35549 if (SWIG_IsTmpObj(res4)) {
35550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35551 } else {
35552 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35554 }
35555 {
35556 if (temp2)
35557 delete arg2;
35558 }
35559 return resultobj;
35560 fail:
35561 {
35562 if (temp2)
35563 delete arg2;
35564 }
35565 return NULL;
35566 }
35567
35568
35569 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35570 PyObject *resultobj = 0;
35571 wxWindow *arg1 = (wxWindow *) 0 ;
35572 wxString *arg2 = 0 ;
35573 int *arg3 = (int *) 0 ;
35574 int *arg4 = (int *) 0 ;
35575 int *arg5 = (int *) 0 ;
35576 int *arg6 = (int *) 0 ;
35577 wxFont *arg7 = (wxFont *) NULL ;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 bool temp2 = false ;
35581 int temp3 ;
35582 int res3 = SWIG_TMPOBJ ;
35583 int temp4 ;
35584 int res4 = SWIG_TMPOBJ ;
35585 int temp5 ;
35586 int res5 = SWIG_TMPOBJ ;
35587 int temp6 ;
35588 int res6 = SWIG_TMPOBJ ;
35589 void *argp7 = 0 ;
35590 int res7 = 0 ;
35591 PyObject * obj0 = 0 ;
35592 PyObject * obj1 = 0 ;
35593 PyObject * obj2 = 0 ;
35594 char * kwnames[] = {
35595 (char *) "self",(char *) "string",(char *) "font", NULL
35596 };
35597
35598 arg3 = &temp3;
35599 arg4 = &temp4;
35600 arg5 = &temp5;
35601 arg6 = &temp6;
35602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35604 if (!SWIG_IsOK(res1)) {
35605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35606 }
35607 arg1 = reinterpret_cast< wxWindow * >(argp1);
35608 {
35609 arg2 = wxString_in_helper(obj1);
35610 if (arg2 == NULL) SWIG_fail;
35611 temp2 = true;
35612 }
35613 if (obj2) {
35614 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35615 if (!SWIG_IsOK(res7)) {
35616 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35617 }
35618 arg7 = reinterpret_cast< wxFont * >(argp7);
35619 }
35620 {
35621 PyThreadState* __tstate = wxPyBeginAllowThreads();
35622 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35623 wxPyEndAllowThreads(__tstate);
35624 if (PyErr_Occurred()) SWIG_fail;
35625 }
35626 resultobj = SWIG_Py_Void();
35627 if (SWIG_IsTmpObj(res3)) {
35628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35629 } else {
35630 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35632 }
35633 if (SWIG_IsTmpObj(res4)) {
35634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35635 } else {
35636 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35638 }
35639 if (SWIG_IsTmpObj(res5)) {
35640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35641 } else {
35642 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35644 }
35645 if (SWIG_IsTmpObj(res6)) {
35646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35647 } else {
35648 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35650 }
35651 {
35652 if (temp2)
35653 delete arg2;
35654 }
35655 return resultobj;
35656 fail:
35657 {
35658 if (temp2)
35659 delete arg2;
35660 }
35661 return NULL;
35662 }
35663
35664
35665 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35666 PyObject *resultobj = 0;
35667 wxWindow *arg1 = (wxWindow *) 0 ;
35668 int *arg2 = (int *) 0 ;
35669 int *arg3 = (int *) 0 ;
35670 void *argp1 = 0 ;
35671 int res1 = 0 ;
35672 int temp2 ;
35673 int res2 = 0 ;
35674 int temp3 ;
35675 int res3 = 0 ;
35676 PyObject * obj0 = 0 ;
35677 PyObject * obj1 = 0 ;
35678 PyObject * obj2 = 0 ;
35679 char * kwnames[] = {
35680 (char *) "self",(char *) "x",(char *) "y", NULL
35681 };
35682
35683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35690 int val;
35691 int ecode = SWIG_AsVal_int(obj1, &val);
35692 if (!SWIG_IsOK(ecode)) {
35693 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35694 }
35695 temp2 = static_cast< int >(val);
35696 arg2 = &temp2;
35697 res2 = SWIG_AddTmpMask(ecode);
35698 }
35699 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35700 int val;
35701 int ecode = SWIG_AsVal_int(obj2, &val);
35702 if (!SWIG_IsOK(ecode)) {
35703 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35704 }
35705 temp3 = static_cast< int >(val);
35706 arg3 = &temp3;
35707 res3 = SWIG_AddTmpMask(ecode);
35708 }
35709 {
35710 PyThreadState* __tstate = wxPyBeginAllowThreads();
35711 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 resultobj = SWIG_Py_Void();
35716 if (SWIG_IsTmpObj(res2)) {
35717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35718 } else {
35719 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35721 }
35722 if (SWIG_IsTmpObj(res3)) {
35723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35724 } else {
35725 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35727 }
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35735 PyObject *resultobj = 0;
35736 wxWindow *arg1 = (wxWindow *) 0 ;
35737 int *arg2 = (int *) 0 ;
35738 int *arg3 = (int *) 0 ;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 int temp2 ;
35742 int res2 = 0 ;
35743 int temp3 ;
35744 int res3 = 0 ;
35745 PyObject * obj0 = 0 ;
35746 PyObject * obj1 = 0 ;
35747 PyObject * obj2 = 0 ;
35748 char * kwnames[] = {
35749 (char *) "self",(char *) "x",(char *) "y", NULL
35750 };
35751
35752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35754 if (!SWIG_IsOK(res1)) {
35755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35756 }
35757 arg1 = reinterpret_cast< wxWindow * >(argp1);
35758 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35759 int val;
35760 int ecode = SWIG_AsVal_int(obj1, &val);
35761 if (!SWIG_IsOK(ecode)) {
35762 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35763 }
35764 temp2 = static_cast< int >(val);
35765 arg2 = &temp2;
35766 res2 = SWIG_AddTmpMask(ecode);
35767 }
35768 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35769 int val;
35770 int ecode = SWIG_AsVal_int(obj2, &val);
35771 if (!SWIG_IsOK(ecode)) {
35772 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35773 }
35774 temp3 = static_cast< int >(val);
35775 arg3 = &temp3;
35776 res3 = SWIG_AddTmpMask(ecode);
35777 }
35778 {
35779 PyThreadState* __tstate = wxPyBeginAllowThreads();
35780 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 resultobj = SWIG_Py_Void();
35785 if (SWIG_IsTmpObj(res2)) {
35786 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35787 } else {
35788 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35789 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35790 }
35791 if (SWIG_IsTmpObj(res3)) {
35792 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35793 } else {
35794 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35796 }
35797 return resultobj;
35798 fail:
35799 return NULL;
35800 }
35801
35802
35803 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35804 PyObject *resultobj = 0;
35805 wxWindow *arg1 = (wxWindow *) 0 ;
35806 wxPoint *arg2 = 0 ;
35807 wxPoint result;
35808 void *argp1 = 0 ;
35809 int res1 = 0 ;
35810 wxPoint temp2 ;
35811 PyObject * obj0 = 0 ;
35812 PyObject * obj1 = 0 ;
35813 char * kwnames[] = {
35814 (char *) "self",(char *) "pt", NULL
35815 };
35816
35817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35819 if (!SWIG_IsOK(res1)) {
35820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35821 }
35822 arg1 = reinterpret_cast< wxWindow * >(argp1);
35823 {
35824 arg2 = &temp2;
35825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35826 }
35827 {
35828 PyThreadState* __tstate = wxPyBeginAllowThreads();
35829 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35830 wxPyEndAllowThreads(__tstate);
35831 if (PyErr_Occurred()) SWIG_fail;
35832 }
35833 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35834 return resultobj;
35835 fail:
35836 return NULL;
35837 }
35838
35839
35840 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35841 PyObject *resultobj = 0;
35842 wxWindow *arg1 = (wxWindow *) 0 ;
35843 wxPoint *arg2 = 0 ;
35844 wxPoint result;
35845 void *argp1 = 0 ;
35846 int res1 = 0 ;
35847 wxPoint temp2 ;
35848 PyObject * obj0 = 0 ;
35849 PyObject * obj1 = 0 ;
35850 char * kwnames[] = {
35851 (char *) "self",(char *) "pt", NULL
35852 };
35853
35854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35856 if (!SWIG_IsOK(res1)) {
35857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35858 }
35859 arg1 = reinterpret_cast< wxWindow * >(argp1);
35860 {
35861 arg2 = &temp2;
35862 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35863 }
35864 {
35865 PyThreadState* __tstate = wxPyBeginAllowThreads();
35866 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35867 wxPyEndAllowThreads(__tstate);
35868 if (PyErr_Occurred()) SWIG_fail;
35869 }
35870 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35871 return resultobj;
35872 fail:
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35878 PyObject *resultobj = 0;
35879 wxWindow *arg1 = (wxWindow *) 0 ;
35880 int arg2 ;
35881 int arg3 ;
35882 wxHitTest result;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 int val2 ;
35886 int ecode2 = 0 ;
35887 int val3 ;
35888 int ecode3 = 0 ;
35889 PyObject * obj0 = 0 ;
35890 PyObject * obj1 = 0 ;
35891 PyObject * obj2 = 0 ;
35892 char * kwnames[] = {
35893 (char *) "self",(char *) "x",(char *) "y", NULL
35894 };
35895
35896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35898 if (!SWIG_IsOK(res1)) {
35899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35900 }
35901 arg1 = reinterpret_cast< wxWindow * >(argp1);
35902 ecode2 = SWIG_AsVal_int(obj1, &val2);
35903 if (!SWIG_IsOK(ecode2)) {
35904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35905 }
35906 arg2 = static_cast< int >(val2);
35907 ecode3 = SWIG_AsVal_int(obj2, &val3);
35908 if (!SWIG_IsOK(ecode3)) {
35909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35910 }
35911 arg3 = static_cast< int >(val3);
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 resultobj = SWIG_From_int(static_cast< int >(result));
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj = 0;
35927 wxWindow *arg1 = (wxWindow *) 0 ;
35928 wxPoint *arg2 = 0 ;
35929 wxHitTest result;
35930 void *argp1 = 0 ;
35931 int res1 = 0 ;
35932 wxPoint temp2 ;
35933 PyObject * obj0 = 0 ;
35934 PyObject * obj1 = 0 ;
35935 char * kwnames[] = {
35936 (char *) "self",(char *) "pt", NULL
35937 };
35938
35939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35941 if (!SWIG_IsOK(res1)) {
35942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35943 }
35944 arg1 = reinterpret_cast< wxWindow * >(argp1);
35945 {
35946 arg2 = &temp2;
35947 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35948 }
35949 {
35950 PyThreadState* __tstate = wxPyBeginAllowThreads();
35951 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35952 wxPyEndAllowThreads(__tstate);
35953 if (PyErr_Occurred()) SWIG_fail;
35954 }
35955 resultobj = SWIG_From_int(static_cast< int >(result));
35956 return resultobj;
35957 fail:
35958 return NULL;
35959 }
35960
35961
35962 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35963 PyObject *resultobj = 0;
35964 wxWindow *arg1 = (wxWindow *) 0 ;
35965 long arg2 ;
35966 wxBorder result;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 long val2 ;
35970 int ecode2 = 0 ;
35971
35972 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35974 if (!SWIG_IsOK(res1)) {
35975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35976 }
35977 arg1 = reinterpret_cast< wxWindow * >(argp1);
35978 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35979 if (!SWIG_IsOK(ecode2)) {
35980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35981 }
35982 arg2 = static_cast< long >(val2);
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_From_int(static_cast< int >(result));
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 wxBorder result;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002
36003 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36005 if (!SWIG_IsOK(res1)) {
36006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36007 }
36008 arg1 = reinterpret_cast< wxWindow * >(argp1);
36009 {
36010 PyThreadState* __tstate = wxPyBeginAllowThreads();
36011 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36012 wxPyEndAllowThreads(__tstate);
36013 if (PyErr_Occurred()) SWIG_fail;
36014 }
36015 resultobj = SWIG_From_int(static_cast< int >(result));
36016 return resultobj;
36017 fail:
36018 return NULL;
36019 }
36020
36021
36022 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36023 int argc;
36024 PyObject *argv[3];
36025
36026 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36027 --argc;
36028 if (argc == 1) {
36029 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36030 }
36031 if (argc == 2) {
36032 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36033 }
36034
36035 fail:
36036 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36037 return NULL;
36038 }
36039
36040
36041 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36042 PyObject *resultobj = 0;
36043 wxWindow *arg1 = (wxWindow *) 0 ;
36044 long arg2 = (long) wxUPDATE_UI_NONE ;
36045 void *argp1 = 0 ;
36046 int res1 = 0 ;
36047 long val2 ;
36048 int ecode2 = 0 ;
36049 PyObject * obj0 = 0 ;
36050 PyObject * obj1 = 0 ;
36051 char * kwnames[] = {
36052 (char *) "self",(char *) "flags", NULL
36053 };
36054
36055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36057 if (!SWIG_IsOK(res1)) {
36058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36059 }
36060 arg1 = reinterpret_cast< wxWindow * >(argp1);
36061 if (obj1) {
36062 ecode2 = SWIG_AsVal_long(obj1, &val2);
36063 if (!SWIG_IsOK(ecode2)) {
36064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36065 }
36066 arg2 = static_cast< long >(val2);
36067 }
36068 {
36069 PyThreadState* __tstate = wxPyBeginAllowThreads();
36070 (arg1)->UpdateWindowUI(arg2);
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 resultobj = SWIG_Py_Void();
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj = 0;
36083 wxWindow *arg1 = (wxWindow *) 0 ;
36084 wxMenu *arg2 = (wxMenu *) 0 ;
36085 int arg3 = (int) -1 ;
36086 int arg4 = (int) -1 ;
36087 bool result;
36088 void *argp1 = 0 ;
36089 int res1 = 0 ;
36090 void *argp2 = 0 ;
36091 int res2 = 0 ;
36092 int val3 ;
36093 int ecode3 = 0 ;
36094 int val4 ;
36095 int ecode4 = 0 ;
36096 PyObject * obj0 = 0 ;
36097 PyObject * obj1 = 0 ;
36098 PyObject * obj2 = 0 ;
36099 PyObject * obj3 = 0 ;
36100 char * kwnames[] = {
36101 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36102 };
36103
36104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36106 if (!SWIG_IsOK(res1)) {
36107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36108 }
36109 arg1 = reinterpret_cast< wxWindow * >(argp1);
36110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36111 if (!SWIG_IsOK(res2)) {
36112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36113 }
36114 arg2 = reinterpret_cast< wxMenu * >(argp2);
36115 if (obj2) {
36116 ecode3 = SWIG_AsVal_int(obj2, &val3);
36117 if (!SWIG_IsOK(ecode3)) {
36118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36119 }
36120 arg3 = static_cast< int >(val3);
36121 }
36122 if (obj3) {
36123 ecode4 = SWIG_AsVal_int(obj3, &val4);
36124 if (!SWIG_IsOK(ecode4)) {
36125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36126 }
36127 arg4 = static_cast< int >(val4);
36128 }
36129 {
36130 PyThreadState* __tstate = wxPyBeginAllowThreads();
36131 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36132 wxPyEndAllowThreads(__tstate);
36133 if (PyErr_Occurred()) SWIG_fail;
36134 }
36135 {
36136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36137 }
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36145 PyObject *resultobj = 0;
36146 wxWindow *arg1 = (wxWindow *) 0 ;
36147 wxMenu *arg2 = (wxMenu *) 0 ;
36148 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36149 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36150 bool result;
36151 void *argp1 = 0 ;
36152 int res1 = 0 ;
36153 void *argp2 = 0 ;
36154 int res2 = 0 ;
36155 wxPoint temp3 ;
36156 PyObject * obj0 = 0 ;
36157 PyObject * obj1 = 0 ;
36158 PyObject * obj2 = 0 ;
36159 char * kwnames[] = {
36160 (char *) "self",(char *) "menu",(char *) "pos", NULL
36161 };
36162
36163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36165 if (!SWIG_IsOK(res1)) {
36166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36167 }
36168 arg1 = reinterpret_cast< wxWindow * >(argp1);
36169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36170 if (!SWIG_IsOK(res2)) {
36171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36172 }
36173 arg2 = reinterpret_cast< wxMenu * >(argp2);
36174 if (obj2) {
36175 {
36176 arg3 = &temp3;
36177 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36178 }
36179 }
36180 {
36181 PyThreadState* __tstate = wxPyBeginAllowThreads();
36182 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 {
36187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36188 }
36189 return resultobj;
36190 fail:
36191 return NULL;
36192 }
36193
36194
36195 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36196 PyObject *resultobj = 0;
36197 wxWindow *arg1 = (wxWindow *) 0 ;
36198 bool result;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 PyObject *swig_obj[1] ;
36202
36203 if (!args) SWIG_fail;
36204 swig_obj[0] = args;
36205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36206 if (!SWIG_IsOK(res1)) {
36207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36208 }
36209 arg1 = reinterpret_cast< wxWindow * >(argp1);
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36213 wxPyEndAllowThreads(__tstate);
36214 if (PyErr_Occurred()) SWIG_fail;
36215 }
36216 {
36217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36218 }
36219 return resultobj;
36220 fail:
36221 return NULL;
36222 }
36223
36224
36225 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36226 PyObject *resultobj = 0;
36227 wxWindow *arg1 = (wxWindow *) 0 ;
36228 long result;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 PyObject *swig_obj[1] ;
36232
36233 if (!args) SWIG_fail;
36234 swig_obj[0] = args;
36235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36236 if (!SWIG_IsOK(res1)) {
36237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36238 }
36239 arg1 = reinterpret_cast< wxWindow * >(argp1);
36240 {
36241 PyThreadState* __tstate = wxPyBeginAllowThreads();
36242 result = (long)wxWindow_GetHandle(arg1);
36243 wxPyEndAllowThreads(__tstate);
36244 if (PyErr_Occurred()) SWIG_fail;
36245 }
36246 resultobj = SWIG_From_long(static_cast< long >(result));
36247 return resultobj;
36248 fail:
36249 return NULL;
36250 }
36251
36252
36253 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36254 PyObject *resultobj = 0;
36255 wxWindow *arg1 = (wxWindow *) 0 ;
36256 long arg2 ;
36257 void *argp1 = 0 ;
36258 int res1 = 0 ;
36259 long val2 ;
36260 int ecode2 = 0 ;
36261 PyObject * obj0 = 0 ;
36262 PyObject * obj1 = 0 ;
36263 char * kwnames[] = {
36264 (char *) "self",(char *) "handle", NULL
36265 };
36266
36267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36269 if (!SWIG_IsOK(res1)) {
36270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36271 }
36272 arg1 = reinterpret_cast< wxWindow * >(argp1);
36273 ecode2 = SWIG_AsVal_long(obj1, &val2);
36274 if (!SWIG_IsOK(ecode2)) {
36275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36276 }
36277 arg2 = static_cast< long >(val2);
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 wxWindow_AssociateHandle(arg1,arg2);
36281 wxPyEndAllowThreads(__tstate);
36282 if (PyErr_Occurred()) SWIG_fail;
36283 }
36284 resultobj = SWIG_Py_Void();
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36292 PyObject *resultobj = 0;
36293 wxWindow *arg1 = (wxWindow *) 0 ;
36294 void *argp1 = 0 ;
36295 int res1 = 0 ;
36296 PyObject *swig_obj[1] ;
36297
36298 if (!args) SWIG_fail;
36299 swig_obj[0] = args;
36300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36301 if (!SWIG_IsOK(res1)) {
36302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36303 }
36304 arg1 = reinterpret_cast< wxWindow * >(argp1);
36305 {
36306 PyThreadState* __tstate = wxPyBeginAllowThreads();
36307 (arg1)->DissociateHandle();
36308 wxPyEndAllowThreads(__tstate);
36309 if (PyErr_Occurred()) SWIG_fail;
36310 }
36311 resultobj = SWIG_Py_Void();
36312 return resultobj;
36313 fail:
36314 return NULL;
36315 }
36316
36317
36318 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36319 PyObject *resultobj = 0;
36320 wxWindow *arg1 = (wxWindow *) 0 ;
36321 wxPaintEvent *arg2 = 0 ;
36322 void *argp1 = 0 ;
36323 int res1 = 0 ;
36324 void *argp2 = 0 ;
36325 int res2 = 0 ;
36326 PyObject * obj0 = 0 ;
36327 PyObject * obj1 = 0 ;
36328 char * kwnames[] = {
36329 (char *) "self",(char *) "event", NULL
36330 };
36331
36332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36334 if (!SWIG_IsOK(res1)) {
36335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36336 }
36337 arg1 = reinterpret_cast< wxWindow * >(argp1);
36338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36339 if (!SWIG_IsOK(res2)) {
36340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36341 }
36342 if (!argp2) {
36343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36344 }
36345 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36346 {
36347 PyThreadState* __tstate = wxPyBeginAllowThreads();
36348 (arg1)->OnPaint(*arg2);
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 resultobj = SWIG_Py_Void();
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj = 0;
36361 wxWindow *arg1 = (wxWindow *) 0 ;
36362 int arg2 ;
36363 bool result;
36364 void *argp1 = 0 ;
36365 int res1 = 0 ;
36366 int val2 ;
36367 int ecode2 = 0 ;
36368 PyObject * obj0 = 0 ;
36369 PyObject * obj1 = 0 ;
36370 char * kwnames[] = {
36371 (char *) "self",(char *) "orient", NULL
36372 };
36373
36374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36376 if (!SWIG_IsOK(res1)) {
36377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36378 }
36379 arg1 = reinterpret_cast< wxWindow * >(argp1);
36380 ecode2 = SWIG_AsVal_int(obj1, &val2);
36381 if (!SWIG_IsOK(ecode2)) {
36382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36383 }
36384 arg2 = static_cast< int >(val2);
36385 {
36386 PyThreadState* __tstate = wxPyBeginAllowThreads();
36387 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36388 wxPyEndAllowThreads(__tstate);
36389 if (PyErr_Occurred()) SWIG_fail;
36390 }
36391 {
36392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36393 }
36394 return resultobj;
36395 fail:
36396 return NULL;
36397 }
36398
36399
36400 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36401 PyObject *resultobj = 0;
36402 wxWindow *arg1 = (wxWindow *) 0 ;
36403 int arg2 ;
36404 int arg3 ;
36405 int arg4 ;
36406 int arg5 ;
36407 bool arg6 = (bool) true ;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 int val2 ;
36411 int ecode2 = 0 ;
36412 int val3 ;
36413 int ecode3 = 0 ;
36414 int val4 ;
36415 int ecode4 = 0 ;
36416 int val5 ;
36417 int ecode5 = 0 ;
36418 bool val6 ;
36419 int ecode6 = 0 ;
36420 PyObject * obj0 = 0 ;
36421 PyObject * obj1 = 0 ;
36422 PyObject * obj2 = 0 ;
36423 PyObject * obj3 = 0 ;
36424 PyObject * obj4 = 0 ;
36425 PyObject * obj5 = 0 ;
36426 char * kwnames[] = {
36427 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36428 };
36429
36430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 ecode2 = SWIG_AsVal_int(obj1, &val2);
36437 if (!SWIG_IsOK(ecode2)) {
36438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36439 }
36440 arg2 = static_cast< int >(val2);
36441 ecode3 = SWIG_AsVal_int(obj2, &val3);
36442 if (!SWIG_IsOK(ecode3)) {
36443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36444 }
36445 arg3 = static_cast< int >(val3);
36446 ecode4 = SWIG_AsVal_int(obj3, &val4);
36447 if (!SWIG_IsOK(ecode4)) {
36448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36449 }
36450 arg4 = static_cast< int >(val4);
36451 ecode5 = SWIG_AsVal_int(obj4, &val5);
36452 if (!SWIG_IsOK(ecode5)) {
36453 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36454 }
36455 arg5 = static_cast< int >(val5);
36456 if (obj5) {
36457 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36458 if (!SWIG_IsOK(ecode6)) {
36459 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36460 }
36461 arg6 = static_cast< bool >(val6);
36462 }
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 resultobj = SWIG_Py_Void();
36470 return resultobj;
36471 fail:
36472 return NULL;
36473 }
36474
36475
36476 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36477 PyObject *resultobj = 0;
36478 wxWindow *arg1 = (wxWindow *) 0 ;
36479 int arg2 ;
36480 int arg3 ;
36481 bool arg4 = (bool) true ;
36482 void *argp1 = 0 ;
36483 int res1 = 0 ;
36484 int val2 ;
36485 int ecode2 = 0 ;
36486 int val3 ;
36487 int ecode3 = 0 ;
36488 bool val4 ;
36489 int ecode4 = 0 ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 PyObject * obj2 = 0 ;
36493 PyObject * obj3 = 0 ;
36494 char * kwnames[] = {
36495 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36496 };
36497
36498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36500 if (!SWIG_IsOK(res1)) {
36501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36502 }
36503 arg1 = reinterpret_cast< wxWindow * >(argp1);
36504 ecode2 = SWIG_AsVal_int(obj1, &val2);
36505 if (!SWIG_IsOK(ecode2)) {
36506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36507 }
36508 arg2 = static_cast< int >(val2);
36509 ecode3 = SWIG_AsVal_int(obj2, &val3);
36510 if (!SWIG_IsOK(ecode3)) {
36511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36512 }
36513 arg3 = static_cast< int >(val3);
36514 if (obj3) {
36515 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36516 if (!SWIG_IsOK(ecode4)) {
36517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36518 }
36519 arg4 = static_cast< bool >(val4);
36520 }
36521 {
36522 PyThreadState* __tstate = wxPyBeginAllowThreads();
36523 (arg1)->SetScrollPos(arg2,arg3,arg4);
36524 wxPyEndAllowThreads(__tstate);
36525 if (PyErr_Occurred()) SWIG_fail;
36526 }
36527 resultobj = SWIG_Py_Void();
36528 return resultobj;
36529 fail:
36530 return NULL;
36531 }
36532
36533
36534 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36535 PyObject *resultobj = 0;
36536 wxWindow *arg1 = (wxWindow *) 0 ;
36537 int arg2 ;
36538 int result;
36539 void *argp1 = 0 ;
36540 int res1 = 0 ;
36541 int val2 ;
36542 int ecode2 = 0 ;
36543 PyObject * obj0 = 0 ;
36544 PyObject * obj1 = 0 ;
36545 char * kwnames[] = {
36546 (char *) "self",(char *) "orientation", NULL
36547 };
36548
36549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36551 if (!SWIG_IsOK(res1)) {
36552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36553 }
36554 arg1 = reinterpret_cast< wxWindow * >(argp1);
36555 ecode2 = SWIG_AsVal_int(obj1, &val2);
36556 if (!SWIG_IsOK(ecode2)) {
36557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36558 }
36559 arg2 = static_cast< int >(val2);
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 resultobj = SWIG_From_int(static_cast< int >(result));
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 int arg2 ;
36577 int result;
36578 void *argp1 = 0 ;
36579 int res1 = 0 ;
36580 int val2 ;
36581 int ecode2 = 0 ;
36582 PyObject * obj0 = 0 ;
36583 PyObject * obj1 = 0 ;
36584 char * kwnames[] = {
36585 (char *) "self",(char *) "orientation", NULL
36586 };
36587
36588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36592 }
36593 arg1 = reinterpret_cast< wxWindow * >(argp1);
36594 ecode2 = SWIG_AsVal_int(obj1, &val2);
36595 if (!SWIG_IsOK(ecode2)) {
36596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36597 }
36598 arg2 = static_cast< int >(val2);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 resultobj = SWIG_From_int(static_cast< int >(result));
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 int arg2 ;
36616 int result;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 int val2 ;
36620 int ecode2 = 0 ;
36621 PyObject * obj0 = 0 ;
36622 PyObject * obj1 = 0 ;
36623 char * kwnames[] = {
36624 (char *) "self",(char *) "orientation", NULL
36625 };
36626
36627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36629 if (!SWIG_IsOK(res1)) {
36630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36631 }
36632 arg1 = reinterpret_cast< wxWindow * >(argp1);
36633 ecode2 = SWIG_AsVal_int(obj1, &val2);
36634 if (!SWIG_IsOK(ecode2)) {
36635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36636 }
36637 arg2 = static_cast< int >(val2);
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 resultobj = SWIG_From_int(static_cast< int >(result));
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36652 PyObject *resultobj = 0;
36653 wxWindow *arg1 = (wxWindow *) 0 ;
36654 int arg2 ;
36655 int arg3 ;
36656 wxRect *arg4 = (wxRect *) NULL ;
36657 void *argp1 = 0 ;
36658 int res1 = 0 ;
36659 int val2 ;
36660 int ecode2 = 0 ;
36661 int val3 ;
36662 int ecode3 = 0 ;
36663 void *argp4 = 0 ;
36664 int res4 = 0 ;
36665 PyObject * obj0 = 0 ;
36666 PyObject * obj1 = 0 ;
36667 PyObject * obj2 = 0 ;
36668 PyObject * obj3 = 0 ;
36669 char * kwnames[] = {
36670 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36671 };
36672
36673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36675 if (!SWIG_IsOK(res1)) {
36676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36677 }
36678 arg1 = reinterpret_cast< wxWindow * >(argp1);
36679 ecode2 = SWIG_AsVal_int(obj1, &val2);
36680 if (!SWIG_IsOK(ecode2)) {
36681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36682 }
36683 arg2 = static_cast< int >(val2);
36684 ecode3 = SWIG_AsVal_int(obj2, &val3);
36685 if (!SWIG_IsOK(ecode3)) {
36686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36687 }
36688 arg3 = static_cast< int >(val3);
36689 if (obj3) {
36690 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36691 if (!SWIG_IsOK(res4)) {
36692 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36693 }
36694 arg4 = reinterpret_cast< wxRect * >(argp4);
36695 }
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36699 wxPyEndAllowThreads(__tstate);
36700 if (PyErr_Occurred()) SWIG_fail;
36701 }
36702 resultobj = SWIG_Py_Void();
36703 return resultobj;
36704 fail:
36705 return NULL;
36706 }
36707
36708
36709 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36710 PyObject *resultobj = 0;
36711 wxWindow *arg1 = (wxWindow *) 0 ;
36712 int arg2 ;
36713 bool result;
36714 void *argp1 = 0 ;
36715 int res1 = 0 ;
36716 int val2 ;
36717 int ecode2 = 0 ;
36718 PyObject * obj0 = 0 ;
36719 PyObject * obj1 = 0 ;
36720 char * kwnames[] = {
36721 (char *) "self",(char *) "lines", NULL
36722 };
36723
36724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36726 if (!SWIG_IsOK(res1)) {
36727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36728 }
36729 arg1 = reinterpret_cast< wxWindow * >(argp1);
36730 ecode2 = SWIG_AsVal_int(obj1, &val2);
36731 if (!SWIG_IsOK(ecode2)) {
36732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36733 }
36734 arg2 = static_cast< int >(val2);
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 result = (bool)(arg1)->ScrollLines(arg2);
36738 wxPyEndAllowThreads(__tstate);
36739 if (PyErr_Occurred()) SWIG_fail;
36740 }
36741 {
36742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36743 }
36744 return resultobj;
36745 fail:
36746 return NULL;
36747 }
36748
36749
36750 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36751 PyObject *resultobj = 0;
36752 wxWindow *arg1 = (wxWindow *) 0 ;
36753 int arg2 ;
36754 bool result;
36755 void *argp1 = 0 ;
36756 int res1 = 0 ;
36757 int val2 ;
36758 int ecode2 = 0 ;
36759 PyObject * obj0 = 0 ;
36760 PyObject * obj1 = 0 ;
36761 char * kwnames[] = {
36762 (char *) "self",(char *) "pages", NULL
36763 };
36764
36765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36767 if (!SWIG_IsOK(res1)) {
36768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36769 }
36770 arg1 = reinterpret_cast< wxWindow * >(argp1);
36771 ecode2 = SWIG_AsVal_int(obj1, &val2);
36772 if (!SWIG_IsOK(ecode2)) {
36773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36774 }
36775 arg2 = static_cast< int >(val2);
36776 {
36777 PyThreadState* __tstate = wxPyBeginAllowThreads();
36778 result = (bool)(arg1)->ScrollPages(arg2);
36779 wxPyEndAllowThreads(__tstate);
36780 if (PyErr_Occurred()) SWIG_fail;
36781 }
36782 {
36783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36784 }
36785 return resultobj;
36786 fail:
36787 return NULL;
36788 }
36789
36790
36791 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36792 PyObject *resultobj = 0;
36793 wxWindow *arg1 = (wxWindow *) 0 ;
36794 bool result;
36795 void *argp1 = 0 ;
36796 int res1 = 0 ;
36797 PyObject *swig_obj[1] ;
36798
36799 if (!args) SWIG_fail;
36800 swig_obj[0] = args;
36801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36802 if (!SWIG_IsOK(res1)) {
36803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36804 }
36805 arg1 = reinterpret_cast< wxWindow * >(argp1);
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 result = (bool)(arg1)->LineUp();
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 {
36813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36814 }
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36822 PyObject *resultobj = 0;
36823 wxWindow *arg1 = (wxWindow *) 0 ;
36824 bool result;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 PyObject *swig_obj[1] ;
36828
36829 if (!args) SWIG_fail;
36830 swig_obj[0] = args;
36831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36832 if (!SWIG_IsOK(res1)) {
36833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36834 }
36835 arg1 = reinterpret_cast< wxWindow * >(argp1);
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = (bool)(arg1)->LineDown();
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 {
36843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36844 }
36845 return resultobj;
36846 fail:
36847 return NULL;
36848 }
36849
36850
36851 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36852 PyObject *resultobj = 0;
36853 wxWindow *arg1 = (wxWindow *) 0 ;
36854 bool result;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 PyObject *swig_obj[1] ;
36858
36859 if (!args) SWIG_fail;
36860 swig_obj[0] = args;
36861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36862 if (!SWIG_IsOK(res1)) {
36863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36864 }
36865 arg1 = reinterpret_cast< wxWindow * >(argp1);
36866 {
36867 PyThreadState* __tstate = wxPyBeginAllowThreads();
36868 result = (bool)(arg1)->PageUp();
36869 wxPyEndAllowThreads(__tstate);
36870 if (PyErr_Occurred()) SWIG_fail;
36871 }
36872 {
36873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36874 }
36875 return resultobj;
36876 fail:
36877 return NULL;
36878 }
36879
36880
36881 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 PyObject *resultobj = 0;
36883 wxWindow *arg1 = (wxWindow *) 0 ;
36884 bool result;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 result = (bool)(arg1)->PageDown();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 {
36903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36904 }
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36912 PyObject *resultobj = 0;
36913 wxWindow *arg1 = (wxWindow *) 0 ;
36914 wxString *arg2 = 0 ;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 bool temp2 = false ;
36918 PyObject * obj0 = 0 ;
36919 PyObject * obj1 = 0 ;
36920 char * kwnames[] = {
36921 (char *) "self",(char *) "text", NULL
36922 };
36923
36924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36928 }
36929 arg1 = reinterpret_cast< wxWindow * >(argp1);
36930 {
36931 arg2 = wxString_in_helper(obj1);
36932 if (arg2 == NULL) SWIG_fail;
36933 temp2 = true;
36934 }
36935 {
36936 PyThreadState* __tstate = wxPyBeginAllowThreads();
36937 (arg1)->SetHelpText((wxString const &)*arg2);
36938 wxPyEndAllowThreads(__tstate);
36939 if (PyErr_Occurred()) SWIG_fail;
36940 }
36941 resultobj = SWIG_Py_Void();
36942 {
36943 if (temp2)
36944 delete arg2;
36945 }
36946 return resultobj;
36947 fail:
36948 {
36949 if (temp2)
36950 delete arg2;
36951 }
36952 return NULL;
36953 }
36954
36955
36956 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36957 PyObject *resultobj = 0;
36958 wxWindow *arg1 = (wxWindow *) 0 ;
36959 wxString *arg2 = 0 ;
36960 void *argp1 = 0 ;
36961 int res1 = 0 ;
36962 bool temp2 = false ;
36963 PyObject * obj0 = 0 ;
36964 PyObject * obj1 = 0 ;
36965 char * kwnames[] = {
36966 (char *) "self",(char *) "text", NULL
36967 };
36968
36969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36971 if (!SWIG_IsOK(res1)) {
36972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36973 }
36974 arg1 = reinterpret_cast< wxWindow * >(argp1);
36975 {
36976 arg2 = wxString_in_helper(obj1);
36977 if (arg2 == NULL) SWIG_fail;
36978 temp2 = true;
36979 }
36980 {
36981 PyThreadState* __tstate = wxPyBeginAllowThreads();
36982 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36983 wxPyEndAllowThreads(__tstate);
36984 if (PyErr_Occurred()) SWIG_fail;
36985 }
36986 resultobj = SWIG_Py_Void();
36987 {
36988 if (temp2)
36989 delete arg2;
36990 }
36991 return resultobj;
36992 fail:
36993 {
36994 if (temp2)
36995 delete arg2;
36996 }
36997 return NULL;
36998 }
36999
37000
37001 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37002 PyObject *resultobj = 0;
37003 wxWindow *arg1 = (wxWindow *) 0 ;
37004 wxPoint *arg2 = 0 ;
37005 wxHelpEvent::Origin arg3 ;
37006 wxString result;
37007 void *argp1 = 0 ;
37008 int res1 = 0 ;
37009 wxPoint temp2 ;
37010 void *argp3 ;
37011 int res3 = 0 ;
37012 PyObject * obj0 = 0 ;
37013 PyObject * obj1 = 0 ;
37014 PyObject * obj2 = 0 ;
37015 char * kwnames[] = {
37016 (char *) "self",(char *) "pt",(char *) "origin", NULL
37017 };
37018
37019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37021 if (!SWIG_IsOK(res1)) {
37022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37023 }
37024 arg1 = reinterpret_cast< wxWindow * >(argp1);
37025 {
37026 arg2 = &temp2;
37027 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37028 }
37029 {
37030 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37031 if (!SWIG_IsOK(res3)) {
37032 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37033 }
37034 if (!argp3) {
37035 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37036 } else {
37037 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37038 arg3 = *temp;
37039 if (SWIG_IsNewObj(res3)) delete temp;
37040 }
37041 }
37042 {
37043 PyThreadState* __tstate = wxPyBeginAllowThreads();
37044 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37045 wxPyEndAllowThreads(__tstate);
37046 if (PyErr_Occurred()) SWIG_fail;
37047 }
37048 {
37049 #if wxUSE_UNICODE
37050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37051 #else
37052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37053 #endif
37054 }
37055 return resultobj;
37056 fail:
37057 return NULL;
37058 }
37059
37060
37061 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37062 PyObject *resultobj = 0;
37063 wxWindow *arg1 = (wxWindow *) 0 ;
37064 wxString result;
37065 void *argp1 = 0 ;
37066 int res1 = 0 ;
37067 PyObject *swig_obj[1] ;
37068
37069 if (!args) SWIG_fail;
37070 swig_obj[0] = args;
37071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37072 if (!SWIG_IsOK(res1)) {
37073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37074 }
37075 arg1 = reinterpret_cast< wxWindow * >(argp1);
37076 {
37077 PyThreadState* __tstate = wxPyBeginAllowThreads();
37078 result = ((wxWindow const *)arg1)->GetHelpText();
37079 wxPyEndAllowThreads(__tstate);
37080 if (PyErr_Occurred()) SWIG_fail;
37081 }
37082 {
37083 #if wxUSE_UNICODE
37084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37085 #else
37086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37087 #endif
37088 }
37089 return resultobj;
37090 fail:
37091 return NULL;
37092 }
37093
37094
37095 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37096 PyObject *resultobj = 0;
37097 wxWindow *arg1 = (wxWindow *) 0 ;
37098 wxString *arg2 = 0 ;
37099 void *argp1 = 0 ;
37100 int res1 = 0 ;
37101 bool temp2 = false ;
37102 PyObject * obj0 = 0 ;
37103 PyObject * obj1 = 0 ;
37104 char * kwnames[] = {
37105 (char *) "self",(char *) "tip", NULL
37106 };
37107
37108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37110 if (!SWIG_IsOK(res1)) {
37111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37112 }
37113 arg1 = reinterpret_cast< wxWindow * >(argp1);
37114 {
37115 arg2 = wxString_in_helper(obj1);
37116 if (arg2 == NULL) SWIG_fail;
37117 temp2 = true;
37118 }
37119 {
37120 PyThreadState* __tstate = wxPyBeginAllowThreads();
37121 (arg1)->SetToolTip((wxString const &)*arg2);
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 resultobj = SWIG_Py_Void();
37126 {
37127 if (temp2)
37128 delete arg2;
37129 }
37130 return resultobj;
37131 fail:
37132 {
37133 if (temp2)
37134 delete arg2;
37135 }
37136 return NULL;
37137 }
37138
37139
37140 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37141 PyObject *resultobj = 0;
37142 wxWindow *arg1 = (wxWindow *) 0 ;
37143 wxToolTip *arg2 = (wxToolTip *) 0 ;
37144 void *argp1 = 0 ;
37145 int res1 = 0 ;
37146 int res2 = 0 ;
37147 PyObject * obj0 = 0 ;
37148 PyObject * obj1 = 0 ;
37149 char * kwnames[] = {
37150 (char *) "self",(char *) "tip", NULL
37151 };
37152
37153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37155 if (!SWIG_IsOK(res1)) {
37156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37157 }
37158 arg1 = reinterpret_cast< wxWindow * >(argp1);
37159 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37160 if (!SWIG_IsOK(res2)) {
37161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37162 }
37163 {
37164 PyThreadState* __tstate = wxPyBeginAllowThreads();
37165 (arg1)->SetToolTip(arg2);
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 resultobj = SWIG_Py_Void();
37170 return resultobj;
37171 fail:
37172 return NULL;
37173 }
37174
37175
37176 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37177 PyObject *resultobj = 0;
37178 wxWindow *arg1 = (wxWindow *) 0 ;
37179 wxToolTip *result = 0 ;
37180 void *argp1 = 0 ;
37181 int res1 = 0 ;
37182 PyObject *swig_obj[1] ;
37183
37184 if (!args) SWIG_fail;
37185 swig_obj[0] = args;
37186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37187 if (!SWIG_IsOK(res1)) {
37188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37189 }
37190 arg1 = reinterpret_cast< wxWindow * >(argp1);
37191 {
37192 PyThreadState* __tstate = wxPyBeginAllowThreads();
37193 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37194 wxPyEndAllowThreads(__tstate);
37195 if (PyErr_Occurred()) SWIG_fail;
37196 }
37197 {
37198 resultobj = wxPyMake_wxObject(result, (bool)0);
37199 }
37200 return resultobj;
37201 fail:
37202 return NULL;
37203 }
37204
37205
37206 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37207 PyObject *resultobj = 0;
37208 wxWindow *arg1 = (wxWindow *) 0 ;
37209 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37210 void *argp1 = 0 ;
37211 int res1 = 0 ;
37212 int res2 = 0 ;
37213 PyObject * obj0 = 0 ;
37214 PyObject * obj1 = 0 ;
37215 char * kwnames[] = {
37216 (char *) "self",(char *) "dropTarget", NULL
37217 };
37218
37219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37221 if (!SWIG_IsOK(res1)) {
37222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37223 }
37224 arg1 = reinterpret_cast< wxWindow * >(argp1);
37225 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37226 if (!SWIG_IsOK(res2)) {
37227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37228 }
37229 {
37230 PyThreadState* __tstate = wxPyBeginAllowThreads();
37231 (arg1)->SetDropTarget(arg2);
37232 wxPyEndAllowThreads(__tstate);
37233 if (PyErr_Occurred()) SWIG_fail;
37234 }
37235 resultobj = SWIG_Py_Void();
37236 return resultobj;
37237 fail:
37238 return NULL;
37239 }
37240
37241
37242 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37243 PyObject *resultobj = 0;
37244 wxWindow *arg1 = (wxWindow *) 0 ;
37245 wxPyDropTarget *result = 0 ;
37246 void *argp1 = 0 ;
37247 int res1 = 0 ;
37248 PyObject *swig_obj[1] ;
37249
37250 if (!args) SWIG_fail;
37251 swig_obj[0] = args;
37252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37253 if (!SWIG_IsOK(res1)) {
37254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37255 }
37256 arg1 = reinterpret_cast< wxWindow * >(argp1);
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37260 wxPyEndAllowThreads(__tstate);
37261 if (PyErr_Occurred()) SWIG_fail;
37262 }
37263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37264 return resultobj;
37265 fail:
37266 return NULL;
37267 }
37268
37269
37270 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37271 PyObject *resultobj = 0;
37272 wxWindow *arg1 = (wxWindow *) 0 ;
37273 bool arg2 ;
37274 void *argp1 = 0 ;
37275 int res1 = 0 ;
37276 bool val2 ;
37277 int ecode2 = 0 ;
37278 PyObject * obj0 = 0 ;
37279 PyObject * obj1 = 0 ;
37280 char * kwnames[] = {
37281 (char *) "self",(char *) "accept", NULL
37282 };
37283
37284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37286 if (!SWIG_IsOK(res1)) {
37287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37288 }
37289 arg1 = reinterpret_cast< wxWindow * >(argp1);
37290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37291 if (!SWIG_IsOK(ecode2)) {
37292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37293 }
37294 arg2 = static_cast< bool >(val2);
37295 {
37296 PyThreadState* __tstate = wxPyBeginAllowThreads();
37297 (arg1)->DragAcceptFiles(arg2);
37298 wxPyEndAllowThreads(__tstate);
37299 if (PyErr_Occurred()) SWIG_fail;
37300 }
37301 resultobj = SWIG_Py_Void();
37302 return resultobj;
37303 fail:
37304 return NULL;
37305 }
37306
37307
37308 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37309 PyObject *resultobj = 0;
37310 wxWindow *arg1 = (wxWindow *) 0 ;
37311 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37312 void *argp1 = 0 ;
37313 int res1 = 0 ;
37314 int res2 = 0 ;
37315 PyObject * obj0 = 0 ;
37316 PyObject * obj1 = 0 ;
37317 char * kwnames[] = {
37318 (char *) "self",(char *) "constraints", NULL
37319 };
37320
37321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37323 if (!SWIG_IsOK(res1)) {
37324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37325 }
37326 arg1 = reinterpret_cast< wxWindow * >(argp1);
37327 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37328 if (!SWIG_IsOK(res2)) {
37329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37330 }
37331 {
37332 PyThreadState* __tstate = wxPyBeginAllowThreads();
37333 (arg1)->SetConstraints(arg2);
37334 wxPyEndAllowThreads(__tstate);
37335 if (PyErr_Occurred()) SWIG_fail;
37336 }
37337 resultobj = SWIG_Py_Void();
37338 return resultobj;
37339 fail:
37340 return NULL;
37341 }
37342
37343
37344 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37345 PyObject *resultobj = 0;
37346 wxWindow *arg1 = (wxWindow *) 0 ;
37347 wxLayoutConstraints *result = 0 ;
37348 void *argp1 = 0 ;
37349 int res1 = 0 ;
37350 PyObject *swig_obj[1] ;
37351
37352 if (!args) SWIG_fail;
37353 swig_obj[0] = args;
37354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37355 if (!SWIG_IsOK(res1)) {
37356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37357 }
37358 arg1 = reinterpret_cast< wxWindow * >(argp1);
37359 {
37360 PyThreadState* __tstate = wxPyBeginAllowThreads();
37361 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37362 wxPyEndAllowThreads(__tstate);
37363 if (PyErr_Occurred()) SWIG_fail;
37364 }
37365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37366 return resultobj;
37367 fail:
37368 return NULL;
37369 }
37370
37371
37372 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37373 PyObject *resultobj = 0;
37374 wxWindow *arg1 = (wxWindow *) 0 ;
37375 bool arg2 ;
37376 void *argp1 = 0 ;
37377 int res1 = 0 ;
37378 bool val2 ;
37379 int ecode2 = 0 ;
37380 PyObject * obj0 = 0 ;
37381 PyObject * obj1 = 0 ;
37382 char * kwnames[] = {
37383 (char *) "self",(char *) "autoLayout", NULL
37384 };
37385
37386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37388 if (!SWIG_IsOK(res1)) {
37389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37390 }
37391 arg1 = reinterpret_cast< wxWindow * >(argp1);
37392 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37393 if (!SWIG_IsOK(ecode2)) {
37394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37395 }
37396 arg2 = static_cast< bool >(val2);
37397 {
37398 PyThreadState* __tstate = wxPyBeginAllowThreads();
37399 (arg1)->SetAutoLayout(arg2);
37400 wxPyEndAllowThreads(__tstate);
37401 if (PyErr_Occurred()) SWIG_fail;
37402 }
37403 resultobj = SWIG_Py_Void();
37404 return resultobj;
37405 fail:
37406 return NULL;
37407 }
37408
37409
37410 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37411 PyObject *resultobj = 0;
37412 wxWindow *arg1 = (wxWindow *) 0 ;
37413 bool result;
37414 void *argp1 = 0 ;
37415 int res1 = 0 ;
37416 PyObject *swig_obj[1] ;
37417
37418 if (!args) SWIG_fail;
37419 swig_obj[0] = args;
37420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37421 if (!SWIG_IsOK(res1)) {
37422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37423 }
37424 arg1 = reinterpret_cast< wxWindow * >(argp1);
37425 {
37426 PyThreadState* __tstate = wxPyBeginAllowThreads();
37427 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37428 wxPyEndAllowThreads(__tstate);
37429 if (PyErr_Occurred()) SWIG_fail;
37430 }
37431 {
37432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37433 }
37434 return resultobj;
37435 fail:
37436 return NULL;
37437 }
37438
37439
37440 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37441 PyObject *resultobj = 0;
37442 wxWindow *arg1 = (wxWindow *) 0 ;
37443 bool result;
37444 void *argp1 = 0 ;
37445 int res1 = 0 ;
37446 PyObject *swig_obj[1] ;
37447
37448 if (!args) SWIG_fail;
37449 swig_obj[0] = args;
37450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (bool)(arg1)->Layout();
37458 wxPyEndAllowThreads(__tstate);
37459 if (PyErr_Occurred()) SWIG_fail;
37460 }
37461 {
37462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37463 }
37464 return resultobj;
37465 fail:
37466 return NULL;
37467 }
37468
37469
37470 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37471 PyObject *resultobj = 0;
37472 wxWindow *arg1 = (wxWindow *) 0 ;
37473 wxSizer *arg2 = (wxSizer *) 0 ;
37474 bool arg3 = (bool) true ;
37475 void *argp1 = 0 ;
37476 int res1 = 0 ;
37477 int res2 = 0 ;
37478 bool val3 ;
37479 int ecode3 = 0 ;
37480 PyObject * obj0 = 0 ;
37481 PyObject * obj1 = 0 ;
37482 PyObject * obj2 = 0 ;
37483 char * kwnames[] = {
37484 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37485 };
37486
37487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37489 if (!SWIG_IsOK(res1)) {
37490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37491 }
37492 arg1 = reinterpret_cast< wxWindow * >(argp1);
37493 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37494 if (!SWIG_IsOK(res2)) {
37495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37496 }
37497 if (obj2) {
37498 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37499 if (!SWIG_IsOK(ecode3)) {
37500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37501 }
37502 arg3 = static_cast< bool >(val3);
37503 }
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 (arg1)->SetSizer(arg2,arg3);
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 resultobj = SWIG_Py_Void();
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj = 0;
37519 wxWindow *arg1 = (wxWindow *) 0 ;
37520 wxSizer *arg2 = (wxSizer *) 0 ;
37521 bool arg3 = (bool) true ;
37522 void *argp1 = 0 ;
37523 int res1 = 0 ;
37524 int res2 = 0 ;
37525 bool val3 ;
37526 int ecode3 = 0 ;
37527 PyObject * obj0 = 0 ;
37528 PyObject * obj1 = 0 ;
37529 PyObject * obj2 = 0 ;
37530 char * kwnames[] = {
37531 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37532 };
37533
37534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37536 if (!SWIG_IsOK(res1)) {
37537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37538 }
37539 arg1 = reinterpret_cast< wxWindow * >(argp1);
37540 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37541 if (!SWIG_IsOK(res2)) {
37542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37543 }
37544 if (obj2) {
37545 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37546 if (!SWIG_IsOK(ecode3)) {
37547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37548 }
37549 arg3 = static_cast< bool >(val3);
37550 }
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 (arg1)->SetSizerAndFit(arg2,arg3);
37554 wxPyEndAllowThreads(__tstate);
37555 if (PyErr_Occurred()) SWIG_fail;
37556 }
37557 resultobj = SWIG_Py_Void();
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37565 PyObject *resultobj = 0;
37566 wxWindow *arg1 = (wxWindow *) 0 ;
37567 wxSizer *result = 0 ;
37568 void *argp1 = 0 ;
37569 int res1 = 0 ;
37570 PyObject *swig_obj[1] ;
37571
37572 if (!args) SWIG_fail;
37573 swig_obj[0] = args;
37574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37575 if (!SWIG_IsOK(res1)) {
37576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37577 }
37578 arg1 = reinterpret_cast< wxWindow * >(argp1);
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 {
37586 resultobj = wxPyMake_wxObject(result, (bool)0);
37587 }
37588 return resultobj;
37589 fail:
37590 return NULL;
37591 }
37592
37593
37594 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37595 PyObject *resultobj = 0;
37596 wxWindow *arg1 = (wxWindow *) 0 ;
37597 wxSizer *arg2 = (wxSizer *) 0 ;
37598 void *argp1 = 0 ;
37599 int res1 = 0 ;
37600 void *argp2 = 0 ;
37601 int res2 = 0 ;
37602 PyObject * obj0 = 0 ;
37603 PyObject * obj1 = 0 ;
37604 char * kwnames[] = {
37605 (char *) "self",(char *) "sizer", NULL
37606 };
37607
37608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37610 if (!SWIG_IsOK(res1)) {
37611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37612 }
37613 arg1 = reinterpret_cast< wxWindow * >(argp1);
37614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37615 if (!SWIG_IsOK(res2)) {
37616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37617 }
37618 arg2 = reinterpret_cast< wxSizer * >(argp2);
37619 {
37620 PyThreadState* __tstate = wxPyBeginAllowThreads();
37621 (arg1)->SetContainingSizer(arg2);
37622 wxPyEndAllowThreads(__tstate);
37623 if (PyErr_Occurred()) SWIG_fail;
37624 }
37625 resultobj = SWIG_Py_Void();
37626 return resultobj;
37627 fail:
37628 return NULL;
37629 }
37630
37631
37632 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37633 PyObject *resultobj = 0;
37634 wxWindow *arg1 = (wxWindow *) 0 ;
37635 wxSizer *result = 0 ;
37636 void *argp1 = 0 ;
37637 int res1 = 0 ;
37638 PyObject *swig_obj[1] ;
37639
37640 if (!args) SWIG_fail;
37641 swig_obj[0] = args;
37642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37643 if (!SWIG_IsOK(res1)) {
37644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37645 }
37646 arg1 = reinterpret_cast< wxWindow * >(argp1);
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37650 wxPyEndAllowThreads(__tstate);
37651 if (PyErr_Occurred()) SWIG_fail;
37652 }
37653 {
37654 resultobj = wxPyMake_wxObject(result, (bool)0);
37655 }
37656 return resultobj;
37657 fail:
37658 return NULL;
37659 }
37660
37661
37662 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37663 PyObject *resultobj = 0;
37664 wxWindow *arg1 = (wxWindow *) 0 ;
37665 void *argp1 = 0 ;
37666 int res1 = 0 ;
37667 PyObject *swig_obj[1] ;
37668
37669 if (!args) SWIG_fail;
37670 swig_obj[0] = args;
37671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37672 if (!SWIG_IsOK(res1)) {
37673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37674 }
37675 arg1 = reinterpret_cast< wxWindow * >(argp1);
37676 {
37677 PyThreadState* __tstate = wxPyBeginAllowThreads();
37678 (arg1)->InheritAttributes();
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 resultobj = SWIG_Py_Void();
37683 return resultobj;
37684 fail:
37685 return NULL;
37686 }
37687
37688
37689 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37690 PyObject *resultobj = 0;
37691 wxWindow *arg1 = (wxWindow *) 0 ;
37692 bool result;
37693 void *argp1 = 0 ;
37694 int res1 = 0 ;
37695 PyObject *swig_obj[1] ;
37696
37697 if (!args) SWIG_fail;
37698 swig_obj[0] = args;
37699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37700 if (!SWIG_IsOK(res1)) {
37701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37702 }
37703 arg1 = reinterpret_cast< wxWindow * >(argp1);
37704 {
37705 PyThreadState* __tstate = wxPyBeginAllowThreads();
37706 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 {
37711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37712 }
37713 return resultobj;
37714 fail:
37715 return NULL;
37716 }
37717
37718
37719 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37720 PyObject *obj;
37721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37722 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37723 return SWIG_Py_Void();
37724 }
37725
37726 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37727 return SWIG_Python_InitShadowInstance(args);
37728 }
37729
37730 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37731 PyObject *resultobj = 0;
37732 long arg1 ;
37733 wxWindow *arg2 = (wxWindow *) NULL ;
37734 wxWindow *result = 0 ;
37735 long val1 ;
37736 int ecode1 = 0 ;
37737 void *argp2 = 0 ;
37738 int res2 = 0 ;
37739 PyObject * obj0 = 0 ;
37740 PyObject * obj1 = 0 ;
37741 char * kwnames[] = {
37742 (char *) "id",(char *) "parent", NULL
37743 };
37744
37745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37746 ecode1 = SWIG_AsVal_long(obj0, &val1);
37747 if (!SWIG_IsOK(ecode1)) {
37748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37749 }
37750 arg1 = static_cast< long >(val1);
37751 if (obj1) {
37752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37753 if (!SWIG_IsOK(res2)) {
37754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37755 }
37756 arg2 = reinterpret_cast< wxWindow * >(argp2);
37757 }
37758 {
37759 if (!wxPyCheckForApp()) SWIG_fail;
37760 PyThreadState* __tstate = wxPyBeginAllowThreads();
37761 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37762 wxPyEndAllowThreads(__tstate);
37763 if (PyErr_Occurred()) SWIG_fail;
37764 }
37765 {
37766 resultobj = wxPyMake_wxObject(result, 0);
37767 }
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37775 PyObject *resultobj = 0;
37776 wxString *arg1 = 0 ;
37777 wxWindow *arg2 = (wxWindow *) NULL ;
37778 wxWindow *result = 0 ;
37779 bool temp1 = false ;
37780 void *argp2 = 0 ;
37781 int res2 = 0 ;
37782 PyObject * obj0 = 0 ;
37783 PyObject * obj1 = 0 ;
37784 char * kwnames[] = {
37785 (char *) "name",(char *) "parent", NULL
37786 };
37787
37788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37789 {
37790 arg1 = wxString_in_helper(obj0);
37791 if (arg1 == NULL) SWIG_fail;
37792 temp1 = true;
37793 }
37794 if (obj1) {
37795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37796 if (!SWIG_IsOK(res2)) {
37797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37798 }
37799 arg2 = reinterpret_cast< wxWindow * >(argp2);
37800 }
37801 {
37802 if (!wxPyCheckForApp()) SWIG_fail;
37803 PyThreadState* __tstate = wxPyBeginAllowThreads();
37804 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 {
37809 resultobj = wxPyMake_wxObject(result, 0);
37810 }
37811 {
37812 if (temp1)
37813 delete arg1;
37814 }
37815 return resultobj;
37816 fail:
37817 {
37818 if (temp1)
37819 delete arg1;
37820 }
37821 return NULL;
37822 }
37823
37824
37825 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37826 PyObject *resultobj = 0;
37827 wxString *arg1 = 0 ;
37828 wxWindow *arg2 = (wxWindow *) NULL ;
37829 wxWindow *result = 0 ;
37830 bool temp1 = false ;
37831 void *argp2 = 0 ;
37832 int res2 = 0 ;
37833 PyObject * obj0 = 0 ;
37834 PyObject * obj1 = 0 ;
37835 char * kwnames[] = {
37836 (char *) "label",(char *) "parent", NULL
37837 };
37838
37839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37840 {
37841 arg1 = wxString_in_helper(obj0);
37842 if (arg1 == NULL) SWIG_fail;
37843 temp1 = true;
37844 }
37845 if (obj1) {
37846 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37847 if (!SWIG_IsOK(res2)) {
37848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37849 }
37850 arg2 = reinterpret_cast< wxWindow * >(argp2);
37851 }
37852 {
37853 if (!wxPyCheckForApp()) SWIG_fail;
37854 PyThreadState* __tstate = wxPyBeginAllowThreads();
37855 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37856 wxPyEndAllowThreads(__tstate);
37857 if (PyErr_Occurred()) SWIG_fail;
37858 }
37859 {
37860 resultobj = wxPyMake_wxObject(result, 0);
37861 }
37862 {
37863 if (temp1)
37864 delete arg1;
37865 }
37866 return resultobj;
37867 fail:
37868 {
37869 if (temp1)
37870 delete arg1;
37871 }
37872 return NULL;
37873 }
37874
37875
37876 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37877 PyObject *resultobj = 0;
37878 wxWindow *arg1 = (wxWindow *) 0 ;
37879 unsigned long arg2 ;
37880 wxWindow *result = 0 ;
37881 void *argp1 = 0 ;
37882 int res1 = 0 ;
37883 unsigned long val2 ;
37884 int ecode2 = 0 ;
37885 PyObject * obj0 = 0 ;
37886 PyObject * obj1 = 0 ;
37887 char * kwnames[] = {
37888 (char *) "parent",(char *) "_hWnd", NULL
37889 };
37890
37891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37893 if (!SWIG_IsOK(res1)) {
37894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37895 }
37896 arg1 = reinterpret_cast< wxWindow * >(argp1);
37897 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37898 if (!SWIG_IsOK(ecode2)) {
37899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37900 }
37901 arg2 = static_cast< unsigned long >(val2);
37902 {
37903 PyThreadState* __tstate = wxPyBeginAllowThreads();
37904 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37905 wxPyEndAllowThreads(__tstate);
37906 if (PyErr_Occurred()) SWIG_fail;
37907 }
37908 {
37909 resultobj = wxPyMake_wxObject(result, 0);
37910 }
37911 return resultobj;
37912 fail:
37913 return NULL;
37914 }
37915
37916
37917 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37918 PyObject *resultobj = 0;
37919 PyObject *result = 0 ;
37920
37921 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37922 {
37923 PyThreadState* __tstate = wxPyBeginAllowThreads();
37924 result = (PyObject *)GetTopLevelWindows();
37925 wxPyEndAllowThreads(__tstate);
37926 if (PyErr_Occurred()) SWIG_fail;
37927 }
37928 resultobj = result;
37929 return resultobj;
37930 fail:
37931 return NULL;
37932 }
37933
37934
37935 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37936 PyObject *resultobj = 0;
37937 wxValidator *result = 0 ;
37938
37939 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 result = (wxValidator *)new wxValidator();
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37947 return resultobj;
37948 fail:
37949 return NULL;
37950 }
37951
37952
37953 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37954 PyObject *resultobj = 0;
37955 wxValidator *arg1 = (wxValidator *) 0 ;
37956 wxValidator *result = 0 ;
37957 void *argp1 = 0 ;
37958 int res1 = 0 ;
37959 PyObject *swig_obj[1] ;
37960
37961 if (!args) SWIG_fail;
37962 swig_obj[0] = args;
37963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37964 if (!SWIG_IsOK(res1)) {
37965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37966 }
37967 arg1 = reinterpret_cast< wxValidator * >(argp1);
37968 {
37969 PyThreadState* __tstate = wxPyBeginAllowThreads();
37970 result = (wxValidator *)(arg1)->Clone();
37971 wxPyEndAllowThreads(__tstate);
37972 if (PyErr_Occurred()) SWIG_fail;
37973 }
37974 {
37975 resultobj = wxPyMake_wxObject(result, 0);
37976 }
37977 return resultobj;
37978 fail:
37979 return NULL;
37980 }
37981
37982
37983 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37984 PyObject *resultobj = 0;
37985 wxValidator *arg1 = (wxValidator *) 0 ;
37986 wxWindow *arg2 = (wxWindow *) 0 ;
37987 bool result;
37988 void *argp1 = 0 ;
37989 int res1 = 0 ;
37990 void *argp2 = 0 ;
37991 int res2 = 0 ;
37992 PyObject * obj0 = 0 ;
37993 PyObject * obj1 = 0 ;
37994 char * kwnames[] = {
37995 (char *) "self",(char *) "parent", NULL
37996 };
37997
37998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38000 if (!SWIG_IsOK(res1)) {
38001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38002 }
38003 arg1 = reinterpret_cast< wxValidator * >(argp1);
38004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38005 if (!SWIG_IsOK(res2)) {
38006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38007 }
38008 arg2 = reinterpret_cast< wxWindow * >(argp2);
38009 {
38010 PyThreadState* __tstate = wxPyBeginAllowThreads();
38011 result = (bool)(arg1)->Validate(arg2);
38012 wxPyEndAllowThreads(__tstate);
38013 if (PyErr_Occurred()) SWIG_fail;
38014 }
38015 {
38016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38017 }
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38025 PyObject *resultobj = 0;
38026 wxValidator *arg1 = (wxValidator *) 0 ;
38027 bool result;
38028 void *argp1 = 0 ;
38029 int res1 = 0 ;
38030 PyObject *swig_obj[1] ;
38031
38032 if (!args) SWIG_fail;
38033 swig_obj[0] = args;
38034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38035 if (!SWIG_IsOK(res1)) {
38036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38037 }
38038 arg1 = reinterpret_cast< wxValidator * >(argp1);
38039 {
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 result = (bool)(arg1)->TransferToWindow();
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 {
38046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38047 }
38048 return resultobj;
38049 fail:
38050 return NULL;
38051 }
38052
38053
38054 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38055 PyObject *resultobj = 0;
38056 wxValidator *arg1 = (wxValidator *) 0 ;
38057 bool result;
38058 void *argp1 = 0 ;
38059 int res1 = 0 ;
38060 PyObject *swig_obj[1] ;
38061
38062 if (!args) SWIG_fail;
38063 swig_obj[0] = args;
38064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38065 if (!SWIG_IsOK(res1)) {
38066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38067 }
38068 arg1 = reinterpret_cast< wxValidator * >(argp1);
38069 {
38070 PyThreadState* __tstate = wxPyBeginAllowThreads();
38071 result = (bool)(arg1)->TransferFromWindow();
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 {
38076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38077 }
38078 return resultobj;
38079 fail:
38080 return NULL;
38081 }
38082
38083
38084 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38085 PyObject *resultobj = 0;
38086 wxValidator *arg1 = (wxValidator *) 0 ;
38087 wxWindow *result = 0 ;
38088 void *argp1 = 0 ;
38089 int res1 = 0 ;
38090 PyObject *swig_obj[1] ;
38091
38092 if (!args) SWIG_fail;
38093 swig_obj[0] = args;
38094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38095 if (!SWIG_IsOK(res1)) {
38096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38097 }
38098 arg1 = reinterpret_cast< wxValidator * >(argp1);
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 result = (wxWindow *)(arg1)->GetWindow();
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_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38115 PyObject *resultobj = 0;
38116 wxValidator *arg1 = (wxValidator *) 0 ;
38117 wxWindow *arg2 = (wxWindow *) 0 ;
38118 void *argp1 = 0 ;
38119 int res1 = 0 ;
38120 void *argp2 = 0 ;
38121 int res2 = 0 ;
38122 PyObject * obj0 = 0 ;
38123 PyObject * obj1 = 0 ;
38124 char * kwnames[] = {
38125 (char *) "self",(char *) "window", NULL
38126 };
38127
38128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38130 if (!SWIG_IsOK(res1)) {
38131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38132 }
38133 arg1 = reinterpret_cast< wxValidator * >(argp1);
38134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38135 if (!SWIG_IsOK(res2)) {
38136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38137 }
38138 arg2 = reinterpret_cast< wxWindow * >(argp2);
38139 {
38140 PyThreadState* __tstate = wxPyBeginAllowThreads();
38141 (arg1)->SetWindow(arg2);
38142 wxPyEndAllowThreads(__tstate);
38143 if (PyErr_Occurred()) SWIG_fail;
38144 }
38145 resultobj = SWIG_Py_Void();
38146 return resultobj;
38147 fail:
38148 return NULL;
38149 }
38150
38151
38152 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38153 PyObject *resultobj = 0;
38154 bool result;
38155
38156 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38157 {
38158 PyThreadState* __tstate = wxPyBeginAllowThreads();
38159 result = (bool)wxValidator::IsSilent();
38160 wxPyEndAllowThreads(__tstate);
38161 if (PyErr_Occurred()) SWIG_fail;
38162 }
38163 {
38164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38165 }
38166 return resultobj;
38167 fail:
38168 return NULL;
38169 }
38170
38171
38172 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38173 PyObject *resultobj = 0;
38174 int arg1 = (int) true ;
38175 int val1 ;
38176 int ecode1 = 0 ;
38177 PyObject * obj0 = 0 ;
38178 char * kwnames[] = {
38179 (char *) "doIt", NULL
38180 };
38181
38182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38183 if (obj0) {
38184 ecode1 = SWIG_AsVal_int(obj0, &val1);
38185 if (!SWIG_IsOK(ecode1)) {
38186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38187 }
38188 arg1 = static_cast< int >(val1);
38189 }
38190 {
38191 PyThreadState* __tstate = wxPyBeginAllowThreads();
38192 wxValidator::SetBellOnError(arg1);
38193 wxPyEndAllowThreads(__tstate);
38194 if (PyErr_Occurred()) SWIG_fail;
38195 }
38196 resultobj = SWIG_Py_Void();
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38204 PyObject *obj;
38205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38206 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38207 return SWIG_Py_Void();
38208 }
38209
38210 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38211 return SWIG_Python_InitShadowInstance(args);
38212 }
38213
38214 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38215 PyObject *resultobj = 0;
38216 wxPyValidator *result = 0 ;
38217
38218 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38219 {
38220 PyThreadState* __tstate = wxPyBeginAllowThreads();
38221 result = (wxPyValidator *)new wxPyValidator();
38222 wxPyEndAllowThreads(__tstate);
38223 if (PyErr_Occurred()) SWIG_fail;
38224 }
38225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38226 return resultobj;
38227 fail:
38228 return NULL;
38229 }
38230
38231
38232 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38233 PyObject *resultobj = 0;
38234 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38235 PyObject *arg2 = (PyObject *) 0 ;
38236 PyObject *arg3 = (PyObject *) 0 ;
38237 int arg4 = (int) true ;
38238 void *argp1 = 0 ;
38239 int res1 = 0 ;
38240 int val4 ;
38241 int ecode4 = 0 ;
38242 PyObject * obj0 = 0 ;
38243 PyObject * obj1 = 0 ;
38244 PyObject * obj2 = 0 ;
38245 PyObject * obj3 = 0 ;
38246 char * kwnames[] = {
38247 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38248 };
38249
38250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38252 if (!SWIG_IsOK(res1)) {
38253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38254 }
38255 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38256 arg2 = obj1;
38257 arg3 = obj2;
38258 if (obj3) {
38259 ecode4 = SWIG_AsVal_int(obj3, &val4);
38260 if (!SWIG_IsOK(ecode4)) {
38261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38262 }
38263 arg4 = static_cast< int >(val4);
38264 }
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 resultobj = SWIG_Py_Void();
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38279 PyObject *obj;
38280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38281 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38282 return SWIG_Py_Void();
38283 }
38284
38285 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38286 return SWIG_Python_InitShadowInstance(args);
38287 }
38288
38289 SWIGINTERN int DefaultValidator_set(PyObject *) {
38290 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38291 return 1;
38292 }
38293
38294
38295 SWIGINTERN PyObject *DefaultValidator_get(void) {
38296 PyObject *pyobj = 0;
38297
38298 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38299 return pyobj;
38300 }
38301
38302
38303 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj = 0;
38305 wxString const &arg1_defvalue = wxPyEmptyString ;
38306 wxString *arg1 = (wxString *) &arg1_defvalue ;
38307 long arg2 = (long) 0 ;
38308 wxMenu *result = 0 ;
38309 bool temp1 = false ;
38310 long val2 ;
38311 int ecode2 = 0 ;
38312 PyObject * obj0 = 0 ;
38313 PyObject * obj1 = 0 ;
38314 char * kwnames[] = {
38315 (char *) "title",(char *) "style", NULL
38316 };
38317
38318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38319 if (obj0) {
38320 {
38321 arg1 = wxString_in_helper(obj0);
38322 if (arg1 == NULL) SWIG_fail;
38323 temp1 = true;
38324 }
38325 }
38326 if (obj1) {
38327 ecode2 = SWIG_AsVal_long(obj1, &val2);
38328 if (!SWIG_IsOK(ecode2)) {
38329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38330 }
38331 arg2 = static_cast< long >(val2);
38332 }
38333 {
38334 if (!wxPyCheckForApp()) SWIG_fail;
38335 PyThreadState* __tstate = wxPyBeginAllowThreads();
38336 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38337 wxPyEndAllowThreads(__tstate);
38338 if (PyErr_Occurred()) SWIG_fail;
38339 }
38340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38341 {
38342 if (temp1)
38343 delete arg1;
38344 }
38345 return resultobj;
38346 fail:
38347 {
38348 if (temp1)
38349 delete arg1;
38350 }
38351 return NULL;
38352 }
38353
38354
38355 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38356 PyObject *resultobj = 0;
38357 wxMenu *arg1 = (wxMenu *) 0 ;
38358 int arg2 ;
38359 wxString *arg3 = 0 ;
38360 wxString const &arg4_defvalue = wxPyEmptyString ;
38361 wxString *arg4 = (wxString *) &arg4_defvalue ;
38362 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38363 wxMenuItem *result = 0 ;
38364 void *argp1 = 0 ;
38365 int res1 = 0 ;
38366 int val2 ;
38367 int ecode2 = 0 ;
38368 bool temp3 = false ;
38369 bool temp4 = false ;
38370 int val5 ;
38371 int ecode5 = 0 ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 PyObject * obj2 = 0 ;
38375 PyObject * obj3 = 0 ;
38376 PyObject * obj4 = 0 ;
38377 char * kwnames[] = {
38378 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38379 };
38380
38381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38385 }
38386 arg1 = reinterpret_cast< wxMenu * >(argp1);
38387 ecode2 = SWIG_AsVal_int(obj1, &val2);
38388 if (!SWIG_IsOK(ecode2)) {
38389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38390 }
38391 arg2 = static_cast< int >(val2);
38392 {
38393 arg3 = wxString_in_helper(obj2);
38394 if (arg3 == NULL) SWIG_fail;
38395 temp3 = true;
38396 }
38397 if (obj3) {
38398 {
38399 arg4 = wxString_in_helper(obj3);
38400 if (arg4 == NULL) SWIG_fail;
38401 temp4 = true;
38402 }
38403 }
38404 if (obj4) {
38405 ecode5 = SWIG_AsVal_int(obj4, &val5);
38406 if (!SWIG_IsOK(ecode5)) {
38407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38408 }
38409 arg5 = static_cast< wxItemKind >(val5);
38410 }
38411 {
38412 PyThreadState* __tstate = wxPyBeginAllowThreads();
38413 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38414 wxPyEndAllowThreads(__tstate);
38415 if (PyErr_Occurred()) SWIG_fail;
38416 }
38417 {
38418 resultobj = wxPyMake_wxObject(result, (bool)0);
38419 }
38420 {
38421 if (temp3)
38422 delete arg3;
38423 }
38424 {
38425 if (temp4)
38426 delete arg4;
38427 }
38428 return resultobj;
38429 fail:
38430 {
38431 if (temp3)
38432 delete arg3;
38433 }
38434 {
38435 if (temp4)
38436 delete arg4;
38437 }
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38443 PyObject *resultobj = 0;
38444 wxMenu *arg1 = (wxMenu *) 0 ;
38445 wxMenuItem *result = 0 ;
38446 void *argp1 = 0 ;
38447 int res1 = 0 ;
38448 PyObject *swig_obj[1] ;
38449
38450 if (!args) SWIG_fail;
38451 swig_obj[0] = args;
38452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38455 }
38456 arg1 = reinterpret_cast< wxMenu * >(argp1);
38457 {
38458 PyThreadState* __tstate = wxPyBeginAllowThreads();
38459 result = (wxMenuItem *)(arg1)->AppendSeparator();
38460 wxPyEndAllowThreads(__tstate);
38461 if (PyErr_Occurred()) SWIG_fail;
38462 }
38463 {
38464 resultobj = wxPyMake_wxObject(result, (bool)0);
38465 }
38466 return resultobj;
38467 fail:
38468 return NULL;
38469 }
38470
38471
38472 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38473 PyObject *resultobj = 0;
38474 wxMenu *arg1 = (wxMenu *) 0 ;
38475 int arg2 ;
38476 wxString *arg3 = 0 ;
38477 wxString const &arg4_defvalue = wxPyEmptyString ;
38478 wxString *arg4 = (wxString *) &arg4_defvalue ;
38479 wxMenuItem *result = 0 ;
38480 void *argp1 = 0 ;
38481 int res1 = 0 ;
38482 int val2 ;
38483 int ecode2 = 0 ;
38484 bool temp3 = false ;
38485 bool temp4 = false ;
38486 PyObject * obj0 = 0 ;
38487 PyObject * obj1 = 0 ;
38488 PyObject * obj2 = 0 ;
38489 PyObject * obj3 = 0 ;
38490 char * kwnames[] = {
38491 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38492 };
38493
38494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38496 if (!SWIG_IsOK(res1)) {
38497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38498 }
38499 arg1 = reinterpret_cast< wxMenu * >(argp1);
38500 ecode2 = SWIG_AsVal_int(obj1, &val2);
38501 if (!SWIG_IsOK(ecode2)) {
38502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38503 }
38504 arg2 = static_cast< int >(val2);
38505 {
38506 arg3 = wxString_in_helper(obj2);
38507 if (arg3 == NULL) SWIG_fail;
38508 temp3 = true;
38509 }
38510 if (obj3) {
38511 {
38512 arg4 = wxString_in_helper(obj3);
38513 if (arg4 == NULL) SWIG_fail;
38514 temp4 = true;
38515 }
38516 }
38517 {
38518 PyThreadState* __tstate = wxPyBeginAllowThreads();
38519 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 {
38524 resultobj = wxPyMake_wxObject(result, (bool)0);
38525 }
38526 {
38527 if (temp3)
38528 delete arg3;
38529 }
38530 {
38531 if (temp4)
38532 delete arg4;
38533 }
38534 return resultobj;
38535 fail:
38536 {
38537 if (temp3)
38538 delete arg3;
38539 }
38540 {
38541 if (temp4)
38542 delete arg4;
38543 }
38544 return NULL;
38545 }
38546
38547
38548 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38549 PyObject *resultobj = 0;
38550 wxMenu *arg1 = (wxMenu *) 0 ;
38551 int arg2 ;
38552 wxString *arg3 = 0 ;
38553 wxString const &arg4_defvalue = wxPyEmptyString ;
38554 wxString *arg4 = (wxString *) &arg4_defvalue ;
38555 wxMenuItem *result = 0 ;
38556 void *argp1 = 0 ;
38557 int res1 = 0 ;
38558 int val2 ;
38559 int ecode2 = 0 ;
38560 bool temp3 = false ;
38561 bool temp4 = false ;
38562 PyObject * obj0 = 0 ;
38563 PyObject * obj1 = 0 ;
38564 PyObject * obj2 = 0 ;
38565 PyObject * obj3 = 0 ;
38566 char * kwnames[] = {
38567 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38568 };
38569
38570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38572 if (!SWIG_IsOK(res1)) {
38573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38574 }
38575 arg1 = reinterpret_cast< wxMenu * >(argp1);
38576 ecode2 = SWIG_AsVal_int(obj1, &val2);
38577 if (!SWIG_IsOK(ecode2)) {
38578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38579 }
38580 arg2 = static_cast< int >(val2);
38581 {
38582 arg3 = wxString_in_helper(obj2);
38583 if (arg3 == NULL) SWIG_fail;
38584 temp3 = true;
38585 }
38586 if (obj3) {
38587 {
38588 arg4 = wxString_in_helper(obj3);
38589 if (arg4 == NULL) SWIG_fail;
38590 temp4 = true;
38591 }
38592 }
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38596 wxPyEndAllowThreads(__tstate);
38597 if (PyErr_Occurred()) SWIG_fail;
38598 }
38599 {
38600 resultobj = wxPyMake_wxObject(result, (bool)0);
38601 }
38602 {
38603 if (temp3)
38604 delete arg3;
38605 }
38606 {
38607 if (temp4)
38608 delete arg4;
38609 }
38610 return resultobj;
38611 fail:
38612 {
38613 if (temp3)
38614 delete arg3;
38615 }
38616 {
38617 if (temp4)
38618 delete arg4;
38619 }
38620 return NULL;
38621 }
38622
38623
38624 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38625 PyObject *resultobj = 0;
38626 wxMenu *arg1 = (wxMenu *) 0 ;
38627 int arg2 ;
38628 wxString *arg3 = 0 ;
38629 wxMenu *arg4 = (wxMenu *) 0 ;
38630 wxString const &arg5_defvalue = wxPyEmptyString ;
38631 wxString *arg5 = (wxString *) &arg5_defvalue ;
38632 wxMenuItem *result = 0 ;
38633 void *argp1 = 0 ;
38634 int res1 = 0 ;
38635 int val2 ;
38636 int ecode2 = 0 ;
38637 bool temp3 = false ;
38638 void *argp4 = 0 ;
38639 int res4 = 0 ;
38640 bool temp5 = false ;
38641 PyObject * obj0 = 0 ;
38642 PyObject * obj1 = 0 ;
38643 PyObject * obj2 = 0 ;
38644 PyObject * obj3 = 0 ;
38645 PyObject * obj4 = 0 ;
38646 char * kwnames[] = {
38647 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38648 };
38649
38650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38652 if (!SWIG_IsOK(res1)) {
38653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38654 }
38655 arg1 = reinterpret_cast< wxMenu * >(argp1);
38656 ecode2 = SWIG_AsVal_int(obj1, &val2);
38657 if (!SWIG_IsOK(ecode2)) {
38658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38659 }
38660 arg2 = static_cast< int >(val2);
38661 {
38662 arg3 = wxString_in_helper(obj2);
38663 if (arg3 == NULL) SWIG_fail;
38664 temp3 = true;
38665 }
38666 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38667 if (!SWIG_IsOK(res4)) {
38668 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38669 }
38670 arg4 = reinterpret_cast< wxMenu * >(argp4);
38671 if (obj4) {
38672 {
38673 arg5 = wxString_in_helper(obj4);
38674 if (arg5 == NULL) SWIG_fail;
38675 temp5 = true;
38676 }
38677 }
38678 {
38679 PyThreadState* __tstate = wxPyBeginAllowThreads();
38680 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38681 wxPyEndAllowThreads(__tstate);
38682 if (PyErr_Occurred()) SWIG_fail;
38683 }
38684 {
38685 resultobj = wxPyMake_wxObject(result, (bool)0);
38686 }
38687 {
38688 if (temp3)
38689 delete arg3;
38690 }
38691 {
38692 if (temp5)
38693 delete arg5;
38694 }
38695 return resultobj;
38696 fail:
38697 {
38698 if (temp3)
38699 delete arg3;
38700 }
38701 {
38702 if (temp5)
38703 delete arg5;
38704 }
38705 return NULL;
38706 }
38707
38708
38709 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38710 PyObject *resultobj = 0;
38711 wxMenu *arg1 = (wxMenu *) 0 ;
38712 wxMenu *arg2 = (wxMenu *) 0 ;
38713 wxString *arg3 = 0 ;
38714 wxString const &arg4_defvalue = wxPyEmptyString ;
38715 wxString *arg4 = (wxString *) &arg4_defvalue ;
38716 wxMenuItem *result = 0 ;
38717 void *argp1 = 0 ;
38718 int res1 = 0 ;
38719 void *argp2 = 0 ;
38720 int res2 = 0 ;
38721 bool temp3 = false ;
38722 bool temp4 = false ;
38723 PyObject * obj0 = 0 ;
38724 PyObject * obj1 = 0 ;
38725 PyObject * obj2 = 0 ;
38726 PyObject * obj3 = 0 ;
38727 char * kwnames[] = {
38728 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38729 };
38730
38731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38733 if (!SWIG_IsOK(res1)) {
38734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38735 }
38736 arg1 = reinterpret_cast< wxMenu * >(argp1);
38737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38738 if (!SWIG_IsOK(res2)) {
38739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38740 }
38741 arg2 = reinterpret_cast< wxMenu * >(argp2);
38742 {
38743 arg3 = wxString_in_helper(obj2);
38744 if (arg3 == NULL) SWIG_fail;
38745 temp3 = true;
38746 }
38747 if (obj3) {
38748 {
38749 arg4 = wxString_in_helper(obj3);
38750 if (arg4 == NULL) SWIG_fail;
38751 temp4 = true;
38752 }
38753 }
38754 {
38755 PyThreadState* __tstate = wxPyBeginAllowThreads();
38756 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38757 wxPyEndAllowThreads(__tstate);
38758 if (PyErr_Occurred()) SWIG_fail;
38759 }
38760 {
38761 resultobj = wxPyMake_wxObject(result, (bool)0);
38762 }
38763 {
38764 if (temp3)
38765 delete arg3;
38766 }
38767 {
38768 if (temp4)
38769 delete arg4;
38770 }
38771 return resultobj;
38772 fail:
38773 {
38774 if (temp3)
38775 delete arg3;
38776 }
38777 {
38778 if (temp4)
38779 delete arg4;
38780 }
38781 return NULL;
38782 }
38783
38784
38785 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38786 PyObject *resultobj = 0;
38787 wxMenu *arg1 = (wxMenu *) 0 ;
38788 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38789 wxMenuItem *result = 0 ;
38790 void *argp1 = 0 ;
38791 int res1 = 0 ;
38792 int res2 = 0 ;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 char * kwnames[] = {
38796 (char *) "self",(char *) "item", NULL
38797 };
38798
38799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38803 }
38804 arg1 = reinterpret_cast< wxMenu * >(argp1);
38805 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38806 if (!SWIG_IsOK(res2)) {
38807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38808 }
38809 {
38810 PyThreadState* __tstate = wxPyBeginAllowThreads();
38811 result = (wxMenuItem *)(arg1)->Append(arg2);
38812 wxPyEndAllowThreads(__tstate);
38813 if (PyErr_Occurred()) SWIG_fail;
38814 }
38815 {
38816 resultobj = wxPyMake_wxObject(result, (bool)0);
38817 }
38818 return resultobj;
38819 fail:
38820 return NULL;
38821 }
38822
38823
38824 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38825 PyObject *resultobj = 0;
38826 wxMenu *arg1 = (wxMenu *) 0 ;
38827 size_t arg2 ;
38828 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38829 wxMenuItem *result = 0 ;
38830 void *argp1 = 0 ;
38831 int res1 = 0 ;
38832 size_t val2 ;
38833 int ecode2 = 0 ;
38834 int res3 = 0 ;
38835 PyObject * obj0 = 0 ;
38836 PyObject * obj1 = 0 ;
38837 PyObject * obj2 = 0 ;
38838 char * kwnames[] = {
38839 (char *) "self",(char *) "pos",(char *) "item", NULL
38840 };
38841
38842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38844 if (!SWIG_IsOK(res1)) {
38845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38846 }
38847 arg1 = reinterpret_cast< wxMenu * >(argp1);
38848 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38849 if (!SWIG_IsOK(ecode2)) {
38850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38851 }
38852 arg2 = static_cast< size_t >(val2);
38853 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38854 if (!SWIG_IsOK(res3)) {
38855 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38856 }
38857 {
38858 PyThreadState* __tstate = wxPyBeginAllowThreads();
38859 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 {
38864 resultobj = wxPyMake_wxObject(result, (bool)0);
38865 }
38866 return resultobj;
38867 fail:
38868 return NULL;
38869 }
38870
38871
38872 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38873 PyObject *resultobj = 0;
38874 wxMenu *arg1 = (wxMenu *) 0 ;
38875 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38876 wxMenuItem *result = 0 ;
38877 void *argp1 = 0 ;
38878 int res1 = 0 ;
38879 int res2 = 0 ;
38880 PyObject * obj0 = 0 ;
38881 PyObject * obj1 = 0 ;
38882 char * kwnames[] = {
38883 (char *) "self",(char *) "item", NULL
38884 };
38885
38886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38888 if (!SWIG_IsOK(res1)) {
38889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38890 }
38891 arg1 = reinterpret_cast< wxMenu * >(argp1);
38892 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38893 if (!SWIG_IsOK(res2)) {
38894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38895 }
38896 {
38897 PyThreadState* __tstate = wxPyBeginAllowThreads();
38898 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38899 wxPyEndAllowThreads(__tstate);
38900 if (PyErr_Occurred()) SWIG_fail;
38901 }
38902 {
38903 resultobj = wxPyMake_wxObject(result, (bool)0);
38904 }
38905 return resultobj;
38906 fail:
38907 return NULL;
38908 }
38909
38910
38911 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38912 PyObject *resultobj = 0;
38913 wxMenu *arg1 = (wxMenu *) 0 ;
38914 void *argp1 = 0 ;
38915 int res1 = 0 ;
38916 PyObject *swig_obj[1] ;
38917
38918 if (!args) SWIG_fail;
38919 swig_obj[0] = args;
38920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38921 if (!SWIG_IsOK(res1)) {
38922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38923 }
38924 arg1 = reinterpret_cast< wxMenu * >(argp1);
38925 {
38926 PyThreadState* __tstate = wxPyBeginAllowThreads();
38927 (arg1)->Break();
38928 wxPyEndAllowThreads(__tstate);
38929 if (PyErr_Occurred()) SWIG_fail;
38930 }
38931 resultobj = SWIG_Py_Void();
38932 return resultobj;
38933 fail:
38934 return NULL;
38935 }
38936
38937
38938 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38939 PyObject *resultobj = 0;
38940 wxMenu *arg1 = (wxMenu *) 0 ;
38941 size_t arg2 ;
38942 int arg3 ;
38943 wxString *arg4 = 0 ;
38944 wxString const &arg5_defvalue = wxPyEmptyString ;
38945 wxString *arg5 = (wxString *) &arg5_defvalue ;
38946 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38947 wxMenuItem *result = 0 ;
38948 void *argp1 = 0 ;
38949 int res1 = 0 ;
38950 size_t val2 ;
38951 int ecode2 = 0 ;
38952 int val3 ;
38953 int ecode3 = 0 ;
38954 bool temp4 = false ;
38955 bool temp5 = false ;
38956 int val6 ;
38957 int ecode6 = 0 ;
38958 PyObject * obj0 = 0 ;
38959 PyObject * obj1 = 0 ;
38960 PyObject * obj2 = 0 ;
38961 PyObject * obj3 = 0 ;
38962 PyObject * obj4 = 0 ;
38963 PyObject * obj5 = 0 ;
38964 char * kwnames[] = {
38965 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38966 };
38967
38968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38970 if (!SWIG_IsOK(res1)) {
38971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38972 }
38973 arg1 = reinterpret_cast< wxMenu * >(argp1);
38974 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38975 if (!SWIG_IsOK(ecode2)) {
38976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38977 }
38978 arg2 = static_cast< size_t >(val2);
38979 ecode3 = SWIG_AsVal_int(obj2, &val3);
38980 if (!SWIG_IsOK(ecode3)) {
38981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38982 }
38983 arg3 = static_cast< int >(val3);
38984 {
38985 arg4 = wxString_in_helper(obj3);
38986 if (arg4 == NULL) SWIG_fail;
38987 temp4 = true;
38988 }
38989 if (obj4) {
38990 {
38991 arg5 = wxString_in_helper(obj4);
38992 if (arg5 == NULL) SWIG_fail;
38993 temp5 = true;
38994 }
38995 }
38996 if (obj5) {
38997 ecode6 = SWIG_AsVal_int(obj5, &val6);
38998 if (!SWIG_IsOK(ecode6)) {
38999 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39000 }
39001 arg6 = static_cast< wxItemKind >(val6);
39002 }
39003 {
39004 PyThreadState* __tstate = wxPyBeginAllowThreads();
39005 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39006 wxPyEndAllowThreads(__tstate);
39007 if (PyErr_Occurred()) SWIG_fail;
39008 }
39009 {
39010 resultobj = wxPyMake_wxObject(result, (bool)0);
39011 }
39012 {
39013 if (temp4)
39014 delete arg4;
39015 }
39016 {
39017 if (temp5)
39018 delete arg5;
39019 }
39020 return resultobj;
39021 fail:
39022 {
39023 if (temp4)
39024 delete arg4;
39025 }
39026 {
39027 if (temp5)
39028 delete arg5;
39029 }
39030 return NULL;
39031 }
39032
39033
39034 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39035 PyObject *resultobj = 0;
39036 wxMenu *arg1 = (wxMenu *) 0 ;
39037 size_t arg2 ;
39038 wxMenuItem *result = 0 ;
39039 void *argp1 = 0 ;
39040 int res1 = 0 ;
39041 size_t val2 ;
39042 int ecode2 = 0 ;
39043 PyObject * obj0 = 0 ;
39044 PyObject * obj1 = 0 ;
39045 char * kwnames[] = {
39046 (char *) "self",(char *) "pos", NULL
39047 };
39048
39049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39051 if (!SWIG_IsOK(res1)) {
39052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39053 }
39054 arg1 = reinterpret_cast< wxMenu * >(argp1);
39055 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39056 if (!SWIG_IsOK(ecode2)) {
39057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39058 }
39059 arg2 = static_cast< size_t >(val2);
39060 {
39061 PyThreadState* __tstate = wxPyBeginAllowThreads();
39062 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39063 wxPyEndAllowThreads(__tstate);
39064 if (PyErr_Occurred()) SWIG_fail;
39065 }
39066 {
39067 resultobj = wxPyMake_wxObject(result, (bool)0);
39068 }
39069 return resultobj;
39070 fail:
39071 return NULL;
39072 }
39073
39074
39075 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39076 PyObject *resultobj = 0;
39077 wxMenu *arg1 = (wxMenu *) 0 ;
39078 size_t arg2 ;
39079 int arg3 ;
39080 wxString *arg4 = 0 ;
39081 wxString const &arg5_defvalue = wxPyEmptyString ;
39082 wxString *arg5 = (wxString *) &arg5_defvalue ;
39083 wxMenuItem *result = 0 ;
39084 void *argp1 = 0 ;
39085 int res1 = 0 ;
39086 size_t val2 ;
39087 int ecode2 = 0 ;
39088 int val3 ;
39089 int ecode3 = 0 ;
39090 bool temp4 = false ;
39091 bool temp5 = false ;
39092 PyObject * obj0 = 0 ;
39093 PyObject * obj1 = 0 ;
39094 PyObject * obj2 = 0 ;
39095 PyObject * obj3 = 0 ;
39096 PyObject * obj4 = 0 ;
39097 char * kwnames[] = {
39098 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39099 };
39100
39101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39103 if (!SWIG_IsOK(res1)) {
39104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39105 }
39106 arg1 = reinterpret_cast< wxMenu * >(argp1);
39107 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39108 if (!SWIG_IsOK(ecode2)) {
39109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39110 }
39111 arg2 = static_cast< size_t >(val2);
39112 ecode3 = SWIG_AsVal_int(obj2, &val3);
39113 if (!SWIG_IsOK(ecode3)) {
39114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39115 }
39116 arg3 = static_cast< int >(val3);
39117 {
39118 arg4 = wxString_in_helper(obj3);
39119 if (arg4 == NULL) SWIG_fail;
39120 temp4 = true;
39121 }
39122 if (obj4) {
39123 {
39124 arg5 = wxString_in_helper(obj4);
39125 if (arg5 == NULL) SWIG_fail;
39126 temp5 = true;
39127 }
39128 }
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39132 wxPyEndAllowThreads(__tstate);
39133 if (PyErr_Occurred()) SWIG_fail;
39134 }
39135 {
39136 resultobj = wxPyMake_wxObject(result, (bool)0);
39137 }
39138 {
39139 if (temp4)
39140 delete arg4;
39141 }
39142 {
39143 if (temp5)
39144 delete arg5;
39145 }
39146 return resultobj;
39147 fail:
39148 {
39149 if (temp4)
39150 delete arg4;
39151 }
39152 {
39153 if (temp5)
39154 delete arg5;
39155 }
39156 return NULL;
39157 }
39158
39159
39160 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39161 PyObject *resultobj = 0;
39162 wxMenu *arg1 = (wxMenu *) 0 ;
39163 size_t arg2 ;
39164 int arg3 ;
39165 wxString *arg4 = 0 ;
39166 wxString const &arg5_defvalue = wxPyEmptyString ;
39167 wxString *arg5 = (wxString *) &arg5_defvalue ;
39168 wxMenuItem *result = 0 ;
39169 void *argp1 = 0 ;
39170 int res1 = 0 ;
39171 size_t val2 ;
39172 int ecode2 = 0 ;
39173 int val3 ;
39174 int ecode3 = 0 ;
39175 bool temp4 = false ;
39176 bool temp5 = false ;
39177 PyObject * obj0 = 0 ;
39178 PyObject * obj1 = 0 ;
39179 PyObject * obj2 = 0 ;
39180 PyObject * obj3 = 0 ;
39181 PyObject * obj4 = 0 ;
39182 char * kwnames[] = {
39183 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39184 };
39185
39186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39188 if (!SWIG_IsOK(res1)) {
39189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39190 }
39191 arg1 = reinterpret_cast< wxMenu * >(argp1);
39192 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39193 if (!SWIG_IsOK(ecode2)) {
39194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39195 }
39196 arg2 = static_cast< size_t >(val2);
39197 ecode3 = SWIG_AsVal_int(obj2, &val3);
39198 if (!SWIG_IsOK(ecode3)) {
39199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39200 }
39201 arg3 = static_cast< int >(val3);
39202 {
39203 arg4 = wxString_in_helper(obj3);
39204 if (arg4 == NULL) SWIG_fail;
39205 temp4 = true;
39206 }
39207 if (obj4) {
39208 {
39209 arg5 = wxString_in_helper(obj4);
39210 if (arg5 == NULL) SWIG_fail;
39211 temp5 = true;
39212 }
39213 }
39214 {
39215 PyThreadState* __tstate = wxPyBeginAllowThreads();
39216 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39217 wxPyEndAllowThreads(__tstate);
39218 if (PyErr_Occurred()) SWIG_fail;
39219 }
39220 {
39221 resultobj = wxPyMake_wxObject(result, (bool)0);
39222 }
39223 {
39224 if (temp4)
39225 delete arg4;
39226 }
39227 {
39228 if (temp5)
39229 delete arg5;
39230 }
39231 return resultobj;
39232 fail:
39233 {
39234 if (temp4)
39235 delete arg4;
39236 }
39237 {
39238 if (temp5)
39239 delete arg5;
39240 }
39241 return NULL;
39242 }
39243
39244
39245 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39246 PyObject *resultobj = 0;
39247 wxMenu *arg1 = (wxMenu *) 0 ;
39248 size_t arg2 ;
39249 int arg3 ;
39250 wxString *arg4 = 0 ;
39251 wxMenu *arg5 = (wxMenu *) 0 ;
39252 wxString const &arg6_defvalue = wxPyEmptyString ;
39253 wxString *arg6 = (wxString *) &arg6_defvalue ;
39254 wxMenuItem *result = 0 ;
39255 void *argp1 = 0 ;
39256 int res1 = 0 ;
39257 size_t val2 ;
39258 int ecode2 = 0 ;
39259 int val3 ;
39260 int ecode3 = 0 ;
39261 bool temp4 = false ;
39262 void *argp5 = 0 ;
39263 int res5 = 0 ;
39264 bool temp6 = false ;
39265 PyObject * obj0 = 0 ;
39266 PyObject * obj1 = 0 ;
39267 PyObject * obj2 = 0 ;
39268 PyObject * obj3 = 0 ;
39269 PyObject * obj4 = 0 ;
39270 PyObject * obj5 = 0 ;
39271 char * kwnames[] = {
39272 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39273 };
39274
39275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39277 if (!SWIG_IsOK(res1)) {
39278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39279 }
39280 arg1 = reinterpret_cast< wxMenu * >(argp1);
39281 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39282 if (!SWIG_IsOK(ecode2)) {
39283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39284 }
39285 arg2 = static_cast< size_t >(val2);
39286 ecode3 = SWIG_AsVal_int(obj2, &val3);
39287 if (!SWIG_IsOK(ecode3)) {
39288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39289 }
39290 arg3 = static_cast< int >(val3);
39291 {
39292 arg4 = wxString_in_helper(obj3);
39293 if (arg4 == NULL) SWIG_fail;
39294 temp4 = true;
39295 }
39296 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39297 if (!SWIG_IsOK(res5)) {
39298 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39299 }
39300 arg5 = reinterpret_cast< wxMenu * >(argp5);
39301 if (obj5) {
39302 {
39303 arg6 = wxString_in_helper(obj5);
39304 if (arg6 == NULL) SWIG_fail;
39305 temp6 = true;
39306 }
39307 }
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39311 wxPyEndAllowThreads(__tstate);
39312 if (PyErr_Occurred()) SWIG_fail;
39313 }
39314 {
39315 resultobj = wxPyMake_wxObject(result, (bool)0);
39316 }
39317 {
39318 if (temp4)
39319 delete arg4;
39320 }
39321 {
39322 if (temp6)
39323 delete arg6;
39324 }
39325 return resultobj;
39326 fail:
39327 {
39328 if (temp4)
39329 delete arg4;
39330 }
39331 {
39332 if (temp6)
39333 delete arg6;
39334 }
39335 return NULL;
39336 }
39337
39338
39339 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39340 PyObject *resultobj = 0;
39341 wxMenu *arg1 = (wxMenu *) 0 ;
39342 int arg2 ;
39343 wxString *arg3 = 0 ;
39344 wxString const &arg4_defvalue = wxPyEmptyString ;
39345 wxString *arg4 = (wxString *) &arg4_defvalue ;
39346 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39347 wxMenuItem *result = 0 ;
39348 void *argp1 = 0 ;
39349 int res1 = 0 ;
39350 int val2 ;
39351 int ecode2 = 0 ;
39352 bool temp3 = false ;
39353 bool temp4 = false ;
39354 int val5 ;
39355 int ecode5 = 0 ;
39356 PyObject * obj0 = 0 ;
39357 PyObject * obj1 = 0 ;
39358 PyObject * obj2 = 0 ;
39359 PyObject * obj3 = 0 ;
39360 PyObject * obj4 = 0 ;
39361 char * kwnames[] = {
39362 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39363 };
39364
39365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39367 if (!SWIG_IsOK(res1)) {
39368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39369 }
39370 arg1 = reinterpret_cast< wxMenu * >(argp1);
39371 ecode2 = SWIG_AsVal_int(obj1, &val2);
39372 if (!SWIG_IsOK(ecode2)) {
39373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39374 }
39375 arg2 = static_cast< int >(val2);
39376 {
39377 arg3 = wxString_in_helper(obj2);
39378 if (arg3 == NULL) SWIG_fail;
39379 temp3 = true;
39380 }
39381 if (obj3) {
39382 {
39383 arg4 = wxString_in_helper(obj3);
39384 if (arg4 == NULL) SWIG_fail;
39385 temp4 = true;
39386 }
39387 }
39388 if (obj4) {
39389 ecode5 = SWIG_AsVal_int(obj4, &val5);
39390 if (!SWIG_IsOK(ecode5)) {
39391 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39392 }
39393 arg5 = static_cast< wxItemKind >(val5);
39394 }
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39398 wxPyEndAllowThreads(__tstate);
39399 if (PyErr_Occurred()) SWIG_fail;
39400 }
39401 {
39402 resultobj = wxPyMake_wxObject(result, (bool)0);
39403 }
39404 {
39405 if (temp3)
39406 delete arg3;
39407 }
39408 {
39409 if (temp4)
39410 delete arg4;
39411 }
39412 return resultobj;
39413 fail:
39414 {
39415 if (temp3)
39416 delete arg3;
39417 }
39418 {
39419 if (temp4)
39420 delete arg4;
39421 }
39422 return NULL;
39423 }
39424
39425
39426 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39427 PyObject *resultobj = 0;
39428 wxMenu *arg1 = (wxMenu *) 0 ;
39429 wxMenuItem *result = 0 ;
39430 void *argp1 = 0 ;
39431 int res1 = 0 ;
39432 PyObject *swig_obj[1] ;
39433
39434 if (!args) SWIG_fail;
39435 swig_obj[0] = args;
39436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39437 if (!SWIG_IsOK(res1)) {
39438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39439 }
39440 arg1 = reinterpret_cast< wxMenu * >(argp1);
39441 {
39442 PyThreadState* __tstate = wxPyBeginAllowThreads();
39443 result = (wxMenuItem *)(arg1)->PrependSeparator();
39444 wxPyEndAllowThreads(__tstate);
39445 if (PyErr_Occurred()) SWIG_fail;
39446 }
39447 {
39448 resultobj = wxPyMake_wxObject(result, (bool)0);
39449 }
39450 return resultobj;
39451 fail:
39452 return NULL;
39453 }
39454
39455
39456 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39457 PyObject *resultobj = 0;
39458 wxMenu *arg1 = (wxMenu *) 0 ;
39459 int arg2 ;
39460 wxString *arg3 = 0 ;
39461 wxString const &arg4_defvalue = wxPyEmptyString ;
39462 wxString *arg4 = (wxString *) &arg4_defvalue ;
39463 wxMenuItem *result = 0 ;
39464 void *argp1 = 0 ;
39465 int res1 = 0 ;
39466 int val2 ;
39467 int ecode2 = 0 ;
39468 bool temp3 = false ;
39469 bool temp4 = false ;
39470 PyObject * obj0 = 0 ;
39471 PyObject * obj1 = 0 ;
39472 PyObject * obj2 = 0 ;
39473 PyObject * obj3 = 0 ;
39474 char * kwnames[] = {
39475 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39476 };
39477
39478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39480 if (!SWIG_IsOK(res1)) {
39481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39482 }
39483 arg1 = reinterpret_cast< wxMenu * >(argp1);
39484 ecode2 = SWIG_AsVal_int(obj1, &val2);
39485 if (!SWIG_IsOK(ecode2)) {
39486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39487 }
39488 arg2 = static_cast< int >(val2);
39489 {
39490 arg3 = wxString_in_helper(obj2);
39491 if (arg3 == NULL) SWIG_fail;
39492 temp3 = true;
39493 }
39494 if (obj3) {
39495 {
39496 arg4 = wxString_in_helper(obj3);
39497 if (arg4 == NULL) SWIG_fail;
39498 temp4 = true;
39499 }
39500 }
39501 {
39502 PyThreadState* __tstate = wxPyBeginAllowThreads();
39503 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39504 wxPyEndAllowThreads(__tstate);
39505 if (PyErr_Occurred()) SWIG_fail;
39506 }
39507 {
39508 resultobj = wxPyMake_wxObject(result, (bool)0);
39509 }
39510 {
39511 if (temp3)
39512 delete arg3;
39513 }
39514 {
39515 if (temp4)
39516 delete arg4;
39517 }
39518 return resultobj;
39519 fail:
39520 {
39521 if (temp3)
39522 delete arg3;
39523 }
39524 {
39525 if (temp4)
39526 delete arg4;
39527 }
39528 return NULL;
39529 }
39530
39531
39532 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39533 PyObject *resultobj = 0;
39534 wxMenu *arg1 = (wxMenu *) 0 ;
39535 int arg2 ;
39536 wxString *arg3 = 0 ;
39537 wxString const &arg4_defvalue = wxPyEmptyString ;
39538 wxString *arg4 = (wxString *) &arg4_defvalue ;
39539 wxMenuItem *result = 0 ;
39540 void *argp1 = 0 ;
39541 int res1 = 0 ;
39542 int val2 ;
39543 int ecode2 = 0 ;
39544 bool temp3 = false ;
39545 bool temp4 = false ;
39546 PyObject * obj0 = 0 ;
39547 PyObject * obj1 = 0 ;
39548 PyObject * obj2 = 0 ;
39549 PyObject * obj3 = 0 ;
39550 char * kwnames[] = {
39551 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39552 };
39553
39554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39556 if (!SWIG_IsOK(res1)) {
39557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39558 }
39559 arg1 = reinterpret_cast< wxMenu * >(argp1);
39560 ecode2 = SWIG_AsVal_int(obj1, &val2);
39561 if (!SWIG_IsOK(ecode2)) {
39562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39563 }
39564 arg2 = static_cast< int >(val2);
39565 {
39566 arg3 = wxString_in_helper(obj2);
39567 if (arg3 == NULL) SWIG_fail;
39568 temp3 = true;
39569 }
39570 if (obj3) {
39571 {
39572 arg4 = wxString_in_helper(obj3);
39573 if (arg4 == NULL) SWIG_fail;
39574 temp4 = true;
39575 }
39576 }
39577 {
39578 PyThreadState* __tstate = wxPyBeginAllowThreads();
39579 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39580 wxPyEndAllowThreads(__tstate);
39581 if (PyErr_Occurred()) SWIG_fail;
39582 }
39583 {
39584 resultobj = wxPyMake_wxObject(result, (bool)0);
39585 }
39586 {
39587 if (temp3)
39588 delete arg3;
39589 }
39590 {
39591 if (temp4)
39592 delete arg4;
39593 }
39594 return resultobj;
39595 fail:
39596 {
39597 if (temp3)
39598 delete arg3;
39599 }
39600 {
39601 if (temp4)
39602 delete arg4;
39603 }
39604 return NULL;
39605 }
39606
39607
39608 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39609 PyObject *resultobj = 0;
39610 wxMenu *arg1 = (wxMenu *) 0 ;
39611 int arg2 ;
39612 wxString *arg3 = 0 ;
39613 wxMenu *arg4 = (wxMenu *) 0 ;
39614 wxString const &arg5_defvalue = wxPyEmptyString ;
39615 wxString *arg5 = (wxString *) &arg5_defvalue ;
39616 wxMenuItem *result = 0 ;
39617 void *argp1 = 0 ;
39618 int res1 = 0 ;
39619 int val2 ;
39620 int ecode2 = 0 ;
39621 bool temp3 = false ;
39622 void *argp4 = 0 ;
39623 int res4 = 0 ;
39624 bool temp5 = false ;
39625 PyObject * obj0 = 0 ;
39626 PyObject * obj1 = 0 ;
39627 PyObject * obj2 = 0 ;
39628 PyObject * obj3 = 0 ;
39629 PyObject * obj4 = 0 ;
39630 char * kwnames[] = {
39631 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39632 };
39633
39634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39636 if (!SWIG_IsOK(res1)) {
39637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39638 }
39639 arg1 = reinterpret_cast< wxMenu * >(argp1);
39640 ecode2 = SWIG_AsVal_int(obj1, &val2);
39641 if (!SWIG_IsOK(ecode2)) {
39642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39643 }
39644 arg2 = static_cast< int >(val2);
39645 {
39646 arg3 = wxString_in_helper(obj2);
39647 if (arg3 == NULL) SWIG_fail;
39648 temp3 = true;
39649 }
39650 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39651 if (!SWIG_IsOK(res4)) {
39652 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39653 }
39654 arg4 = reinterpret_cast< wxMenu * >(argp4);
39655 if (obj4) {
39656 {
39657 arg5 = wxString_in_helper(obj4);
39658 if (arg5 == NULL) SWIG_fail;
39659 temp5 = true;
39660 }
39661 }
39662 {
39663 PyThreadState* __tstate = wxPyBeginAllowThreads();
39664 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39665 wxPyEndAllowThreads(__tstate);
39666 if (PyErr_Occurred()) SWIG_fail;
39667 }
39668 {
39669 resultobj = wxPyMake_wxObject(result, (bool)0);
39670 }
39671 {
39672 if (temp3)
39673 delete arg3;
39674 }
39675 {
39676 if (temp5)
39677 delete arg5;
39678 }
39679 return resultobj;
39680 fail:
39681 {
39682 if (temp3)
39683 delete arg3;
39684 }
39685 {
39686 if (temp5)
39687 delete arg5;
39688 }
39689 return NULL;
39690 }
39691
39692
39693 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39694 PyObject *resultobj = 0;
39695 wxMenu *arg1 = (wxMenu *) 0 ;
39696 int arg2 ;
39697 wxMenuItem *result = 0 ;
39698 void *argp1 = 0 ;
39699 int res1 = 0 ;
39700 int val2 ;
39701 int ecode2 = 0 ;
39702 PyObject * obj0 = 0 ;
39703 PyObject * obj1 = 0 ;
39704 char * kwnames[] = {
39705 (char *) "self",(char *) "id", NULL
39706 };
39707
39708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39710 if (!SWIG_IsOK(res1)) {
39711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39712 }
39713 arg1 = reinterpret_cast< wxMenu * >(argp1);
39714 ecode2 = SWIG_AsVal_int(obj1, &val2);
39715 if (!SWIG_IsOK(ecode2)) {
39716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39717 }
39718 arg2 = static_cast< int >(val2);
39719 {
39720 PyThreadState* __tstate = wxPyBeginAllowThreads();
39721 result = (wxMenuItem *)(arg1)->Remove(arg2);
39722 wxPyEndAllowThreads(__tstate);
39723 if (PyErr_Occurred()) SWIG_fail;
39724 }
39725 {
39726 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39727 }
39728 return resultobj;
39729 fail:
39730 return NULL;
39731 }
39732
39733
39734 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39735 PyObject *resultobj = 0;
39736 wxMenu *arg1 = (wxMenu *) 0 ;
39737 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39738 wxMenuItem *result = 0 ;
39739 void *argp1 = 0 ;
39740 int res1 = 0 ;
39741 void *argp2 = 0 ;
39742 int res2 = 0 ;
39743 PyObject * obj0 = 0 ;
39744 PyObject * obj1 = 0 ;
39745 char * kwnames[] = {
39746 (char *) "self",(char *) "item", NULL
39747 };
39748
39749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39751 if (!SWIG_IsOK(res1)) {
39752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39753 }
39754 arg1 = reinterpret_cast< wxMenu * >(argp1);
39755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39756 if (!SWIG_IsOK(res2)) {
39757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39758 }
39759 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39760 {
39761 PyThreadState* __tstate = wxPyBeginAllowThreads();
39762 result = (wxMenuItem *)(arg1)->Remove(arg2);
39763 wxPyEndAllowThreads(__tstate);
39764 if (PyErr_Occurred()) SWIG_fail;
39765 }
39766 {
39767 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39768 }
39769 return resultobj;
39770 fail:
39771 return NULL;
39772 }
39773
39774
39775 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39776 PyObject *resultobj = 0;
39777 wxMenu *arg1 = (wxMenu *) 0 ;
39778 int arg2 ;
39779 bool result;
39780 void *argp1 = 0 ;
39781 int res1 = 0 ;
39782 int val2 ;
39783 int ecode2 = 0 ;
39784 PyObject * obj0 = 0 ;
39785 PyObject * obj1 = 0 ;
39786 char * kwnames[] = {
39787 (char *) "self",(char *) "id", NULL
39788 };
39789
39790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39792 if (!SWIG_IsOK(res1)) {
39793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39794 }
39795 arg1 = reinterpret_cast< wxMenu * >(argp1);
39796 ecode2 = SWIG_AsVal_int(obj1, &val2);
39797 if (!SWIG_IsOK(ecode2)) {
39798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39799 }
39800 arg2 = static_cast< int >(val2);
39801 {
39802 PyThreadState* __tstate = wxPyBeginAllowThreads();
39803 result = (bool)(arg1)->Delete(arg2);
39804 wxPyEndAllowThreads(__tstate);
39805 if (PyErr_Occurred()) SWIG_fail;
39806 }
39807 {
39808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39809 }
39810 return resultobj;
39811 fail:
39812 return NULL;
39813 }
39814
39815
39816 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39817 PyObject *resultobj = 0;
39818 wxMenu *arg1 = (wxMenu *) 0 ;
39819 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39820 bool result;
39821 void *argp1 = 0 ;
39822 int res1 = 0 ;
39823 void *argp2 = 0 ;
39824 int res2 = 0 ;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 char * kwnames[] = {
39828 (char *) "self",(char *) "item", NULL
39829 };
39830
39831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) 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_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39835 }
39836 arg1 = reinterpret_cast< wxMenu * >(argp1);
39837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39838 if (!SWIG_IsOK(res2)) {
39839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39840 }
39841 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39842 {
39843 PyThreadState* __tstate = wxPyBeginAllowThreads();
39844 result = (bool)(arg1)->Delete(arg2);
39845 wxPyEndAllowThreads(__tstate);
39846 if (PyErr_Occurred()) SWIG_fail;
39847 }
39848 {
39849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39850 }
39851 return resultobj;
39852 fail:
39853 return NULL;
39854 }
39855
39856
39857 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39858 PyObject *resultobj = 0;
39859 wxMenu *arg1 = (wxMenu *) 0 ;
39860 void *argp1 = 0 ;
39861 int res1 = 0 ;
39862 PyObject *swig_obj[1] ;
39863
39864 if (!args) SWIG_fail;
39865 swig_obj[0] = args;
39866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39867 if (!SWIG_IsOK(res1)) {
39868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39869 }
39870 arg1 = reinterpret_cast< wxMenu * >(argp1);
39871 {
39872 PyThreadState* __tstate = wxPyBeginAllowThreads();
39873 wxMenu_Destroy(arg1);
39874 wxPyEndAllowThreads(__tstate);
39875 if (PyErr_Occurred()) SWIG_fail;
39876 }
39877 resultobj = SWIG_Py_Void();
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj = 0;
39886 wxMenu *arg1 = (wxMenu *) 0 ;
39887 int arg2 ;
39888 bool result;
39889 void *argp1 = 0 ;
39890 int res1 = 0 ;
39891 int val2 ;
39892 int ecode2 = 0 ;
39893 PyObject * obj0 = 0 ;
39894 PyObject * obj1 = 0 ;
39895 char * kwnames[] = {
39896 (char *) "self",(char *) "id", NULL
39897 };
39898
39899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39901 if (!SWIG_IsOK(res1)) {
39902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39903 }
39904 arg1 = reinterpret_cast< wxMenu * >(argp1);
39905 ecode2 = SWIG_AsVal_int(obj1, &val2);
39906 if (!SWIG_IsOK(ecode2)) {
39907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39908 }
39909 arg2 = static_cast< int >(val2);
39910 {
39911 PyThreadState* __tstate = wxPyBeginAllowThreads();
39912 result = (bool)(arg1)->Destroy(arg2);
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 {
39917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39918 }
39919 return resultobj;
39920 fail:
39921 return NULL;
39922 }
39923
39924
39925 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39926 PyObject *resultobj = 0;
39927 wxMenu *arg1 = (wxMenu *) 0 ;
39928 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39929 bool result;
39930 void *argp1 = 0 ;
39931 int res1 = 0 ;
39932 void *argp2 = 0 ;
39933 int res2 = 0 ;
39934 PyObject * obj0 = 0 ;
39935 PyObject * obj1 = 0 ;
39936 char * kwnames[] = {
39937 (char *) "self",(char *) "item", NULL
39938 };
39939
39940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39942 if (!SWIG_IsOK(res1)) {
39943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39944 }
39945 arg1 = reinterpret_cast< wxMenu * >(argp1);
39946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39947 if (!SWIG_IsOK(res2)) {
39948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39949 }
39950 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39951 {
39952 PyThreadState* __tstate = wxPyBeginAllowThreads();
39953 result = (bool)(arg1)->Destroy(arg2);
39954 wxPyEndAllowThreads(__tstate);
39955 if (PyErr_Occurred()) SWIG_fail;
39956 }
39957 {
39958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39959 }
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39967 PyObject *resultobj = 0;
39968 wxMenu *arg1 = (wxMenu *) 0 ;
39969 size_t result;
39970 void *argp1 = 0 ;
39971 int res1 = 0 ;
39972 PyObject *swig_obj[1] ;
39973
39974 if (!args) SWIG_fail;
39975 swig_obj[0] = args;
39976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39977 if (!SWIG_IsOK(res1)) {
39978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39979 }
39980 arg1 = reinterpret_cast< wxMenu * >(argp1);
39981 {
39982 PyThreadState* __tstate = wxPyBeginAllowThreads();
39983 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39995 PyObject *resultobj = 0;
39996 wxMenu *arg1 = (wxMenu *) 0 ;
39997 PyObject *result = 0 ;
39998 void *argp1 = 0 ;
39999 int res1 = 0 ;
40000 PyObject *swig_obj[1] ;
40001
40002 if (!args) SWIG_fail;
40003 swig_obj[0] = args;
40004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40005 if (!SWIG_IsOK(res1)) {
40006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40007 }
40008 arg1 = reinterpret_cast< wxMenu * >(argp1);
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40012 wxPyEndAllowThreads(__tstate);
40013 if (PyErr_Occurred()) SWIG_fail;
40014 }
40015 resultobj = result;
40016 return resultobj;
40017 fail:
40018 return NULL;
40019 }
40020
40021
40022 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40023 PyObject *resultobj = 0;
40024 wxMenu *arg1 = (wxMenu *) 0 ;
40025 wxString *arg2 = 0 ;
40026 int result;
40027 void *argp1 = 0 ;
40028 int res1 = 0 ;
40029 bool temp2 = false ;
40030 PyObject * obj0 = 0 ;
40031 PyObject * obj1 = 0 ;
40032 char * kwnames[] = {
40033 (char *) "self",(char *) "item", NULL
40034 };
40035
40036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40038 if (!SWIG_IsOK(res1)) {
40039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40040 }
40041 arg1 = reinterpret_cast< wxMenu * >(argp1);
40042 {
40043 arg2 = wxString_in_helper(obj1);
40044 if (arg2 == NULL) SWIG_fail;
40045 temp2 = true;
40046 }
40047 {
40048 PyThreadState* __tstate = wxPyBeginAllowThreads();
40049 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 resultobj = SWIG_From_int(static_cast< int >(result));
40054 {
40055 if (temp2)
40056 delete arg2;
40057 }
40058 return resultobj;
40059 fail:
40060 {
40061 if (temp2)
40062 delete arg2;
40063 }
40064 return NULL;
40065 }
40066
40067
40068 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40069 PyObject *resultobj = 0;
40070 wxMenu *arg1 = (wxMenu *) 0 ;
40071 int arg2 ;
40072 wxMenuItem *result = 0 ;
40073 void *argp1 = 0 ;
40074 int res1 = 0 ;
40075 int val2 ;
40076 int ecode2 = 0 ;
40077 PyObject * obj0 = 0 ;
40078 PyObject * obj1 = 0 ;
40079 char * kwnames[] = {
40080 (char *) "self",(char *) "id", NULL
40081 };
40082
40083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40085 if (!SWIG_IsOK(res1)) {
40086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40087 }
40088 arg1 = reinterpret_cast< wxMenu * >(argp1);
40089 ecode2 = SWIG_AsVal_int(obj1, &val2);
40090 if (!SWIG_IsOK(ecode2)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40092 }
40093 arg2 = static_cast< int >(val2);
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40097 wxPyEndAllowThreads(__tstate);
40098 if (PyErr_Occurred()) SWIG_fail;
40099 }
40100 {
40101 resultobj = wxPyMake_wxObject(result, (bool)0);
40102 }
40103 return resultobj;
40104 fail:
40105 return NULL;
40106 }
40107
40108
40109 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40110 PyObject *resultobj = 0;
40111 wxMenu *arg1 = (wxMenu *) 0 ;
40112 size_t arg2 ;
40113 wxMenuItem *result = 0 ;
40114 void *argp1 = 0 ;
40115 int res1 = 0 ;
40116 size_t val2 ;
40117 int ecode2 = 0 ;
40118 PyObject * obj0 = 0 ;
40119 PyObject * obj1 = 0 ;
40120 char * kwnames[] = {
40121 (char *) "self",(char *) "position", NULL
40122 };
40123
40124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40126 if (!SWIG_IsOK(res1)) {
40127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40128 }
40129 arg1 = reinterpret_cast< wxMenu * >(argp1);
40130 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40131 if (!SWIG_IsOK(ecode2)) {
40132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40133 }
40134 arg2 = static_cast< size_t >(val2);
40135 {
40136 PyThreadState* __tstate = wxPyBeginAllowThreads();
40137 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40138 wxPyEndAllowThreads(__tstate);
40139 if (PyErr_Occurred()) SWIG_fail;
40140 }
40141 {
40142 resultobj = wxPyMake_wxObject(result, (bool)0);
40143 }
40144 return resultobj;
40145 fail:
40146 return NULL;
40147 }
40148
40149
40150 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40151 PyObject *resultobj = 0;
40152 wxMenu *arg1 = (wxMenu *) 0 ;
40153 int arg2 ;
40154 bool arg3 ;
40155 void *argp1 = 0 ;
40156 int res1 = 0 ;
40157 int val2 ;
40158 int ecode2 = 0 ;
40159 bool val3 ;
40160 int ecode3 = 0 ;
40161 PyObject * obj0 = 0 ;
40162 PyObject * obj1 = 0 ;
40163 PyObject * obj2 = 0 ;
40164 char * kwnames[] = {
40165 (char *) "self",(char *) "id",(char *) "enable", NULL
40166 };
40167
40168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40170 if (!SWIG_IsOK(res1)) {
40171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40172 }
40173 arg1 = reinterpret_cast< wxMenu * >(argp1);
40174 ecode2 = SWIG_AsVal_int(obj1, &val2);
40175 if (!SWIG_IsOK(ecode2)) {
40176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40177 }
40178 arg2 = static_cast< int >(val2);
40179 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40180 if (!SWIG_IsOK(ecode3)) {
40181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40182 }
40183 arg3 = static_cast< bool >(val3);
40184 {
40185 PyThreadState* __tstate = wxPyBeginAllowThreads();
40186 (arg1)->Enable(arg2,arg3);
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 resultobj = SWIG_Py_Void();
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj = 0;
40199 wxMenu *arg1 = (wxMenu *) 0 ;
40200 int arg2 ;
40201 bool result;
40202 void *argp1 = 0 ;
40203 int res1 = 0 ;
40204 int val2 ;
40205 int ecode2 = 0 ;
40206 PyObject * obj0 = 0 ;
40207 PyObject * obj1 = 0 ;
40208 char * kwnames[] = {
40209 (char *) "self",(char *) "id", NULL
40210 };
40211
40212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40214 if (!SWIG_IsOK(res1)) {
40215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40216 }
40217 arg1 = reinterpret_cast< wxMenu * >(argp1);
40218 ecode2 = SWIG_AsVal_int(obj1, &val2);
40219 if (!SWIG_IsOK(ecode2)) {
40220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40221 }
40222 arg2 = static_cast< int >(val2);
40223 {
40224 PyThreadState* __tstate = wxPyBeginAllowThreads();
40225 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40226 wxPyEndAllowThreads(__tstate);
40227 if (PyErr_Occurred()) SWIG_fail;
40228 }
40229 {
40230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40231 }
40232 return resultobj;
40233 fail:
40234 return NULL;
40235 }
40236
40237
40238 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40239 PyObject *resultobj = 0;
40240 wxMenu *arg1 = (wxMenu *) 0 ;
40241 int arg2 ;
40242 bool arg3 ;
40243 void *argp1 = 0 ;
40244 int res1 = 0 ;
40245 int val2 ;
40246 int ecode2 = 0 ;
40247 bool val3 ;
40248 int ecode3 = 0 ;
40249 PyObject * obj0 = 0 ;
40250 PyObject * obj1 = 0 ;
40251 PyObject * obj2 = 0 ;
40252 char * kwnames[] = {
40253 (char *) "self",(char *) "id",(char *) "check", NULL
40254 };
40255
40256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40258 if (!SWIG_IsOK(res1)) {
40259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40260 }
40261 arg1 = reinterpret_cast< wxMenu * >(argp1);
40262 ecode2 = SWIG_AsVal_int(obj1, &val2);
40263 if (!SWIG_IsOK(ecode2)) {
40264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40265 }
40266 arg2 = static_cast< int >(val2);
40267 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40268 if (!SWIG_IsOK(ecode3)) {
40269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40270 }
40271 arg3 = static_cast< bool >(val3);
40272 {
40273 PyThreadState* __tstate = wxPyBeginAllowThreads();
40274 (arg1)->Check(arg2,arg3);
40275 wxPyEndAllowThreads(__tstate);
40276 if (PyErr_Occurred()) SWIG_fail;
40277 }
40278 resultobj = SWIG_Py_Void();
40279 return resultobj;
40280 fail:
40281 return NULL;
40282 }
40283
40284
40285 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40286 PyObject *resultobj = 0;
40287 wxMenu *arg1 = (wxMenu *) 0 ;
40288 int arg2 ;
40289 bool result;
40290 void *argp1 = 0 ;
40291 int res1 = 0 ;
40292 int val2 ;
40293 int ecode2 = 0 ;
40294 PyObject * obj0 = 0 ;
40295 PyObject * obj1 = 0 ;
40296 char * kwnames[] = {
40297 (char *) "self",(char *) "id", NULL
40298 };
40299
40300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40302 if (!SWIG_IsOK(res1)) {
40303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40304 }
40305 arg1 = reinterpret_cast< wxMenu * >(argp1);
40306 ecode2 = SWIG_AsVal_int(obj1, &val2);
40307 if (!SWIG_IsOK(ecode2)) {
40308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40309 }
40310 arg2 = static_cast< int >(val2);
40311 {
40312 PyThreadState* __tstate = wxPyBeginAllowThreads();
40313 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 {
40318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40319 }
40320 return resultobj;
40321 fail:
40322 return NULL;
40323 }
40324
40325
40326 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40327 PyObject *resultobj = 0;
40328 wxMenu *arg1 = (wxMenu *) 0 ;
40329 int arg2 ;
40330 wxString *arg3 = 0 ;
40331 void *argp1 = 0 ;
40332 int res1 = 0 ;
40333 int val2 ;
40334 int ecode2 = 0 ;
40335 bool temp3 = false ;
40336 PyObject * obj0 = 0 ;
40337 PyObject * obj1 = 0 ;
40338 PyObject * obj2 = 0 ;
40339 char * kwnames[] = {
40340 (char *) "self",(char *) "id",(char *) "label", NULL
40341 };
40342
40343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40345 if (!SWIG_IsOK(res1)) {
40346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40347 }
40348 arg1 = reinterpret_cast< wxMenu * >(argp1);
40349 ecode2 = SWIG_AsVal_int(obj1, &val2);
40350 if (!SWIG_IsOK(ecode2)) {
40351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40352 }
40353 arg2 = static_cast< int >(val2);
40354 {
40355 arg3 = wxString_in_helper(obj2);
40356 if (arg3 == NULL) SWIG_fail;
40357 temp3 = true;
40358 }
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 resultobj = SWIG_Py_Void();
40366 {
40367 if (temp3)
40368 delete arg3;
40369 }
40370 return resultobj;
40371 fail:
40372 {
40373 if (temp3)
40374 delete arg3;
40375 }
40376 return NULL;
40377 }
40378
40379
40380 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40381 PyObject *resultobj = 0;
40382 wxMenu *arg1 = (wxMenu *) 0 ;
40383 int arg2 ;
40384 wxString result;
40385 void *argp1 = 0 ;
40386 int res1 = 0 ;
40387 int val2 ;
40388 int ecode2 = 0 ;
40389 PyObject * obj0 = 0 ;
40390 PyObject * obj1 = 0 ;
40391 char * kwnames[] = {
40392 (char *) "self",(char *) "id", NULL
40393 };
40394
40395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40397 if (!SWIG_IsOK(res1)) {
40398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40399 }
40400 arg1 = reinterpret_cast< wxMenu * >(argp1);
40401 ecode2 = SWIG_AsVal_int(obj1, &val2);
40402 if (!SWIG_IsOK(ecode2)) {
40403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40404 }
40405 arg2 = static_cast< int >(val2);
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40409 wxPyEndAllowThreads(__tstate);
40410 if (PyErr_Occurred()) SWIG_fail;
40411 }
40412 {
40413 #if wxUSE_UNICODE
40414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40415 #else
40416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40417 #endif
40418 }
40419 return resultobj;
40420 fail:
40421 return NULL;
40422 }
40423
40424
40425 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj = 0;
40427 wxMenu *arg1 = (wxMenu *) 0 ;
40428 int arg2 ;
40429 wxString *arg3 = 0 ;
40430 void *argp1 = 0 ;
40431 int res1 = 0 ;
40432 int val2 ;
40433 int ecode2 = 0 ;
40434 bool temp3 = false ;
40435 PyObject * obj0 = 0 ;
40436 PyObject * obj1 = 0 ;
40437 PyObject * obj2 = 0 ;
40438 char * kwnames[] = {
40439 (char *) "self",(char *) "id",(char *) "helpString", NULL
40440 };
40441
40442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40444 if (!SWIG_IsOK(res1)) {
40445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40446 }
40447 arg1 = reinterpret_cast< wxMenu * >(argp1);
40448 ecode2 = SWIG_AsVal_int(obj1, &val2);
40449 if (!SWIG_IsOK(ecode2)) {
40450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40451 }
40452 arg2 = static_cast< int >(val2);
40453 {
40454 arg3 = wxString_in_helper(obj2);
40455 if (arg3 == NULL) SWIG_fail;
40456 temp3 = true;
40457 }
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40461 wxPyEndAllowThreads(__tstate);
40462 if (PyErr_Occurred()) SWIG_fail;
40463 }
40464 resultobj = SWIG_Py_Void();
40465 {
40466 if (temp3)
40467 delete arg3;
40468 }
40469 return resultobj;
40470 fail:
40471 {
40472 if (temp3)
40473 delete arg3;
40474 }
40475 return NULL;
40476 }
40477
40478
40479 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40480 PyObject *resultobj = 0;
40481 wxMenu *arg1 = (wxMenu *) 0 ;
40482 int arg2 ;
40483 wxString result;
40484 void *argp1 = 0 ;
40485 int res1 = 0 ;
40486 int val2 ;
40487 int ecode2 = 0 ;
40488 PyObject * obj0 = 0 ;
40489 PyObject * obj1 = 0 ;
40490 char * kwnames[] = {
40491 (char *) "self",(char *) "id", NULL
40492 };
40493
40494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40496 if (!SWIG_IsOK(res1)) {
40497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40498 }
40499 arg1 = reinterpret_cast< wxMenu * >(argp1);
40500 ecode2 = SWIG_AsVal_int(obj1, &val2);
40501 if (!SWIG_IsOK(ecode2)) {
40502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40503 }
40504 arg2 = static_cast< int >(val2);
40505 {
40506 PyThreadState* __tstate = wxPyBeginAllowThreads();
40507 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40508 wxPyEndAllowThreads(__tstate);
40509 if (PyErr_Occurred()) SWIG_fail;
40510 }
40511 {
40512 #if wxUSE_UNICODE
40513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40514 #else
40515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40516 #endif
40517 }
40518 return resultobj;
40519 fail:
40520 return NULL;
40521 }
40522
40523
40524 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40525 PyObject *resultobj = 0;
40526 wxMenu *arg1 = (wxMenu *) 0 ;
40527 wxString *arg2 = 0 ;
40528 void *argp1 = 0 ;
40529 int res1 = 0 ;
40530 bool temp2 = false ;
40531 PyObject * obj0 = 0 ;
40532 PyObject * obj1 = 0 ;
40533 char * kwnames[] = {
40534 (char *) "self",(char *) "title", NULL
40535 };
40536
40537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40539 if (!SWIG_IsOK(res1)) {
40540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40541 }
40542 arg1 = reinterpret_cast< wxMenu * >(argp1);
40543 {
40544 arg2 = wxString_in_helper(obj1);
40545 if (arg2 == NULL) SWIG_fail;
40546 temp2 = true;
40547 }
40548 {
40549 PyThreadState* __tstate = wxPyBeginAllowThreads();
40550 (arg1)->SetTitle((wxString const &)*arg2);
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 resultobj = SWIG_Py_Void();
40555 {
40556 if (temp2)
40557 delete arg2;
40558 }
40559 return resultobj;
40560 fail:
40561 {
40562 if (temp2)
40563 delete arg2;
40564 }
40565 return NULL;
40566 }
40567
40568
40569 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40570 PyObject *resultobj = 0;
40571 wxMenu *arg1 = (wxMenu *) 0 ;
40572 wxString result;
40573 void *argp1 = 0 ;
40574 int res1 = 0 ;
40575 PyObject *swig_obj[1] ;
40576
40577 if (!args) SWIG_fail;
40578 swig_obj[0] = args;
40579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40580 if (!SWIG_IsOK(res1)) {
40581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40582 }
40583 arg1 = reinterpret_cast< wxMenu * >(argp1);
40584 {
40585 PyThreadState* __tstate = wxPyBeginAllowThreads();
40586 result = ((wxMenu const *)arg1)->GetTitle();
40587 wxPyEndAllowThreads(__tstate);
40588 if (PyErr_Occurred()) SWIG_fail;
40589 }
40590 {
40591 #if wxUSE_UNICODE
40592 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40593 #else
40594 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40595 #endif
40596 }
40597 return resultobj;
40598 fail:
40599 return NULL;
40600 }
40601
40602
40603 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40604 PyObject *resultobj = 0;
40605 wxMenu *arg1 = (wxMenu *) 0 ;
40606 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 void *argp2 = 0 ;
40610 int res2 = 0 ;
40611 PyObject * obj0 = 0 ;
40612 PyObject * obj1 = 0 ;
40613 char * kwnames[] = {
40614 (char *) "self",(char *) "handler", NULL
40615 };
40616
40617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40619 if (!SWIG_IsOK(res1)) {
40620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40621 }
40622 arg1 = reinterpret_cast< wxMenu * >(argp1);
40623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40624 if (!SWIG_IsOK(res2)) {
40625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40626 }
40627 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40628 {
40629 PyThreadState* __tstate = wxPyBeginAllowThreads();
40630 (arg1)->SetEventHandler(arg2);
40631 wxPyEndAllowThreads(__tstate);
40632 if (PyErr_Occurred()) SWIG_fail;
40633 }
40634 resultobj = SWIG_Py_Void();
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40642 PyObject *resultobj = 0;
40643 wxMenu *arg1 = (wxMenu *) 0 ;
40644 wxEvtHandler *result = 0 ;
40645 void *argp1 = 0 ;
40646 int res1 = 0 ;
40647 PyObject *swig_obj[1] ;
40648
40649 if (!args) SWIG_fail;
40650 swig_obj[0] = args;
40651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40652 if (!SWIG_IsOK(res1)) {
40653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40654 }
40655 arg1 = reinterpret_cast< wxMenu * >(argp1);
40656 {
40657 PyThreadState* __tstate = wxPyBeginAllowThreads();
40658 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 {
40663 resultobj = wxPyMake_wxObject(result, 0);
40664 }
40665 return resultobj;
40666 fail:
40667 return NULL;
40668 }
40669
40670
40671 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40672 PyObject *resultobj = 0;
40673 wxMenu *arg1 = (wxMenu *) 0 ;
40674 wxWindow *arg2 = (wxWindow *) 0 ;
40675 void *argp1 = 0 ;
40676 int res1 = 0 ;
40677 void *argp2 = 0 ;
40678 int res2 = 0 ;
40679 PyObject * obj0 = 0 ;
40680 PyObject * obj1 = 0 ;
40681 char * kwnames[] = {
40682 (char *) "self",(char *) "win", NULL
40683 };
40684
40685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40687 if (!SWIG_IsOK(res1)) {
40688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40689 }
40690 arg1 = reinterpret_cast< wxMenu * >(argp1);
40691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40692 if (!SWIG_IsOK(res2)) {
40693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40694 }
40695 arg2 = reinterpret_cast< wxWindow * >(argp2);
40696 {
40697 PyThreadState* __tstate = wxPyBeginAllowThreads();
40698 (arg1)->SetInvokingWindow(arg2);
40699 wxPyEndAllowThreads(__tstate);
40700 if (PyErr_Occurred()) SWIG_fail;
40701 }
40702 resultobj = SWIG_Py_Void();
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40710 PyObject *resultobj = 0;
40711 wxMenu *arg1 = (wxMenu *) 0 ;
40712 wxWindow *result = 0 ;
40713 void *argp1 = 0 ;
40714 int res1 = 0 ;
40715 PyObject *swig_obj[1] ;
40716
40717 if (!args) SWIG_fail;
40718 swig_obj[0] = args;
40719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40720 if (!SWIG_IsOK(res1)) {
40721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40722 }
40723 arg1 = reinterpret_cast< wxMenu * >(argp1);
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40727 wxPyEndAllowThreads(__tstate);
40728 if (PyErr_Occurred()) SWIG_fail;
40729 }
40730 {
40731 resultobj = wxPyMake_wxObject(result, 0);
40732 }
40733 return resultobj;
40734 fail:
40735 return NULL;
40736 }
40737
40738
40739 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40740 PyObject *resultobj = 0;
40741 wxMenu *arg1 = (wxMenu *) 0 ;
40742 long result;
40743 void *argp1 = 0 ;
40744 int res1 = 0 ;
40745 PyObject *swig_obj[1] ;
40746
40747 if (!args) SWIG_fail;
40748 swig_obj[0] = args;
40749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40750 if (!SWIG_IsOK(res1)) {
40751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40752 }
40753 arg1 = reinterpret_cast< wxMenu * >(argp1);
40754 {
40755 PyThreadState* __tstate = wxPyBeginAllowThreads();
40756 result = (long)((wxMenu const *)arg1)->GetStyle();
40757 wxPyEndAllowThreads(__tstate);
40758 if (PyErr_Occurred()) SWIG_fail;
40759 }
40760 resultobj = SWIG_From_long(static_cast< long >(result));
40761 return resultobj;
40762 fail:
40763 return NULL;
40764 }
40765
40766
40767 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40768 PyObject *resultobj = 0;
40769 wxMenu *arg1 = (wxMenu *) 0 ;
40770 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40771 void *argp1 = 0 ;
40772 int res1 = 0 ;
40773 void *argp2 = 0 ;
40774 int res2 = 0 ;
40775 PyObject * obj0 = 0 ;
40776 PyObject * obj1 = 0 ;
40777 char * kwnames[] = {
40778 (char *) "self",(char *) "source", NULL
40779 };
40780
40781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40783 if (!SWIG_IsOK(res1)) {
40784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40785 }
40786 arg1 = reinterpret_cast< wxMenu * >(argp1);
40787 if (obj1) {
40788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40789 if (!SWIG_IsOK(res2)) {
40790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40791 }
40792 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40793 }
40794 {
40795 PyThreadState* __tstate = wxPyBeginAllowThreads();
40796 (arg1)->UpdateUI(arg2);
40797 wxPyEndAllowThreads(__tstate);
40798 if (PyErr_Occurred()) SWIG_fail;
40799 }
40800 resultobj = SWIG_Py_Void();
40801 return resultobj;
40802 fail:
40803 return NULL;
40804 }
40805
40806
40807 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40808 PyObject *resultobj = 0;
40809 wxMenu *arg1 = (wxMenu *) 0 ;
40810 wxMenuBar *result = 0 ;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 PyObject *swig_obj[1] ;
40814
40815 if (!args) SWIG_fail;
40816 swig_obj[0] = args;
40817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40818 if (!SWIG_IsOK(res1)) {
40819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40820 }
40821 arg1 = reinterpret_cast< wxMenu * >(argp1);
40822 {
40823 PyThreadState* __tstate = wxPyBeginAllowThreads();
40824 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40825 wxPyEndAllowThreads(__tstate);
40826 if (PyErr_Occurred()) SWIG_fail;
40827 }
40828 {
40829 resultobj = wxPyMake_wxObject(result, (bool)0);
40830 }
40831 return resultobj;
40832 fail:
40833 return NULL;
40834 }
40835
40836
40837 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40838 PyObject *resultobj = 0;
40839 wxMenu *arg1 = (wxMenu *) 0 ;
40840 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40841 void *argp1 = 0 ;
40842 int res1 = 0 ;
40843 void *argp2 = 0 ;
40844 int res2 = 0 ;
40845 PyObject * obj0 = 0 ;
40846 PyObject * obj1 = 0 ;
40847 char * kwnames[] = {
40848 (char *) "self",(char *) "menubar", NULL
40849 };
40850
40851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40853 if (!SWIG_IsOK(res1)) {
40854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40855 }
40856 arg1 = reinterpret_cast< wxMenu * >(argp1);
40857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40858 if (!SWIG_IsOK(res2)) {
40859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40860 }
40861 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40862 {
40863 PyThreadState* __tstate = wxPyBeginAllowThreads();
40864 (arg1)->Attach(arg2);
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 resultobj = SWIG_Py_Void();
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40876 PyObject *resultobj = 0;
40877 wxMenu *arg1 = (wxMenu *) 0 ;
40878 void *argp1 = 0 ;
40879 int res1 = 0 ;
40880 PyObject *swig_obj[1] ;
40881
40882 if (!args) SWIG_fail;
40883 swig_obj[0] = args;
40884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40885 if (!SWIG_IsOK(res1)) {
40886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40887 }
40888 arg1 = reinterpret_cast< wxMenu * >(argp1);
40889 {
40890 PyThreadState* __tstate = wxPyBeginAllowThreads();
40891 (arg1)->Detach();
40892 wxPyEndAllowThreads(__tstate);
40893 if (PyErr_Occurred()) SWIG_fail;
40894 }
40895 resultobj = SWIG_Py_Void();
40896 return resultobj;
40897 fail:
40898 return NULL;
40899 }
40900
40901
40902 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40903 PyObject *resultobj = 0;
40904 wxMenu *arg1 = (wxMenu *) 0 ;
40905 bool result;
40906 void *argp1 = 0 ;
40907 int res1 = 0 ;
40908 PyObject *swig_obj[1] ;
40909
40910 if (!args) SWIG_fail;
40911 swig_obj[0] = args;
40912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40913 if (!SWIG_IsOK(res1)) {
40914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40915 }
40916 arg1 = reinterpret_cast< wxMenu * >(argp1);
40917 {
40918 PyThreadState* __tstate = wxPyBeginAllowThreads();
40919 result = (bool)((wxMenu const *)arg1)->IsAttached();
40920 wxPyEndAllowThreads(__tstate);
40921 if (PyErr_Occurred()) SWIG_fail;
40922 }
40923 {
40924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40925 }
40926 return resultobj;
40927 fail:
40928 return NULL;
40929 }
40930
40931
40932 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40933 PyObject *resultobj = 0;
40934 wxMenu *arg1 = (wxMenu *) 0 ;
40935 wxMenu *arg2 = (wxMenu *) 0 ;
40936 void *argp1 = 0 ;
40937 int res1 = 0 ;
40938 void *argp2 = 0 ;
40939 int res2 = 0 ;
40940 PyObject * obj0 = 0 ;
40941 PyObject * obj1 = 0 ;
40942 char * kwnames[] = {
40943 (char *) "self",(char *) "parent", NULL
40944 };
40945
40946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40948 if (!SWIG_IsOK(res1)) {
40949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40950 }
40951 arg1 = reinterpret_cast< wxMenu * >(argp1);
40952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40953 if (!SWIG_IsOK(res2)) {
40954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40955 }
40956 arg2 = reinterpret_cast< wxMenu * >(argp2);
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 (arg1)->SetParent(arg2);
40960 wxPyEndAllowThreads(__tstate);
40961 if (PyErr_Occurred()) SWIG_fail;
40962 }
40963 resultobj = SWIG_Py_Void();
40964 return resultobj;
40965 fail:
40966 return NULL;
40967 }
40968
40969
40970 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40971 PyObject *resultobj = 0;
40972 wxMenu *arg1 = (wxMenu *) 0 ;
40973 wxMenu *result = 0 ;
40974 void *argp1 = 0 ;
40975 int res1 = 0 ;
40976 PyObject *swig_obj[1] ;
40977
40978 if (!args) SWIG_fail;
40979 swig_obj[0] = args;
40980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40981 if (!SWIG_IsOK(res1)) {
40982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40983 }
40984 arg1 = reinterpret_cast< wxMenu * >(argp1);
40985 {
40986 PyThreadState* __tstate = wxPyBeginAllowThreads();
40987 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40988 wxPyEndAllowThreads(__tstate);
40989 if (PyErr_Occurred()) SWIG_fail;
40990 }
40991 {
40992 resultobj = wxPyMake_wxObject(result, 0);
40993 }
40994 return resultobj;
40995 fail:
40996 return NULL;
40997 }
40998
40999
41000 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41001 PyObject *obj;
41002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41003 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41004 return SWIG_Py_Void();
41005 }
41006
41007 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41008 return SWIG_Python_InitShadowInstance(args);
41009 }
41010
41011 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41012 PyObject *resultobj = 0;
41013 long arg1 = (long) 0 ;
41014 wxMenuBar *result = 0 ;
41015 long val1 ;
41016 int ecode1 = 0 ;
41017 PyObject * obj0 = 0 ;
41018 char * kwnames[] = {
41019 (char *) "style", NULL
41020 };
41021
41022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41023 if (obj0) {
41024 ecode1 = SWIG_AsVal_long(obj0, &val1);
41025 if (!SWIG_IsOK(ecode1)) {
41026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41027 }
41028 arg1 = static_cast< long >(val1);
41029 }
41030 {
41031 if (!wxPyCheckForApp()) SWIG_fail;
41032 PyThreadState* __tstate = wxPyBeginAllowThreads();
41033 result = (wxMenuBar *)new wxMenuBar(arg1);
41034 wxPyEndAllowThreads(__tstate);
41035 if (PyErr_Occurred()) SWIG_fail;
41036 }
41037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41038 return resultobj;
41039 fail:
41040 return NULL;
41041 }
41042
41043
41044 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41045 PyObject *resultobj = 0;
41046 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41047 wxMenu *arg2 = (wxMenu *) 0 ;
41048 wxString *arg3 = 0 ;
41049 bool result;
41050 void *argp1 = 0 ;
41051 int res1 = 0 ;
41052 void *argp2 = 0 ;
41053 int res2 = 0 ;
41054 bool temp3 = false ;
41055 PyObject * obj0 = 0 ;
41056 PyObject * obj1 = 0 ;
41057 PyObject * obj2 = 0 ;
41058 char * kwnames[] = {
41059 (char *) "self",(char *) "menu",(char *) "title", NULL
41060 };
41061
41062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41064 if (!SWIG_IsOK(res1)) {
41065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41066 }
41067 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41069 if (!SWIG_IsOK(res2)) {
41070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41071 }
41072 arg2 = reinterpret_cast< wxMenu * >(argp2);
41073 {
41074 arg3 = wxString_in_helper(obj2);
41075 if (arg3 == NULL) SWIG_fail;
41076 temp3 = true;
41077 }
41078 {
41079 PyThreadState* __tstate = wxPyBeginAllowThreads();
41080 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 {
41085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41086 }
41087 {
41088 if (temp3)
41089 delete arg3;
41090 }
41091 return resultobj;
41092 fail:
41093 {
41094 if (temp3)
41095 delete arg3;
41096 }
41097 return NULL;
41098 }
41099
41100
41101 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41102 PyObject *resultobj = 0;
41103 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41104 size_t arg2 ;
41105 wxMenu *arg3 = (wxMenu *) 0 ;
41106 wxString *arg4 = 0 ;
41107 bool result;
41108 void *argp1 = 0 ;
41109 int res1 = 0 ;
41110 size_t val2 ;
41111 int ecode2 = 0 ;
41112 void *argp3 = 0 ;
41113 int res3 = 0 ;
41114 bool temp4 = false ;
41115 PyObject * obj0 = 0 ;
41116 PyObject * obj1 = 0 ;
41117 PyObject * obj2 = 0 ;
41118 PyObject * obj3 = 0 ;
41119 char * kwnames[] = {
41120 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41121 };
41122
41123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41125 if (!SWIG_IsOK(res1)) {
41126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41127 }
41128 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41129 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41130 if (!SWIG_IsOK(ecode2)) {
41131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41132 }
41133 arg2 = static_cast< size_t >(val2);
41134 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41135 if (!SWIG_IsOK(res3)) {
41136 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41137 }
41138 arg3 = reinterpret_cast< wxMenu * >(argp3);
41139 {
41140 arg4 = wxString_in_helper(obj3);
41141 if (arg4 == NULL) SWIG_fail;
41142 temp4 = true;
41143 }
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41147 wxPyEndAllowThreads(__tstate);
41148 if (PyErr_Occurred()) SWIG_fail;
41149 }
41150 {
41151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41152 }
41153 {
41154 if (temp4)
41155 delete arg4;
41156 }
41157 return resultobj;
41158 fail:
41159 {
41160 if (temp4)
41161 delete arg4;
41162 }
41163 return NULL;
41164 }
41165
41166
41167 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41168 PyObject *resultobj = 0;
41169 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41170 size_t result;
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_wxMenuBar, 0 | 0 );
41178 if (!SWIG_IsOK(res1)) {
41179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41180 }
41181 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41182 {
41183 PyThreadState* __tstate = wxPyBeginAllowThreads();
41184 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41185 wxPyEndAllowThreads(__tstate);
41186 if (PyErr_Occurred()) SWIG_fail;
41187 }
41188 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj = 0;
41197 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41198 size_t arg2 ;
41199 wxMenu *result = 0 ;
41200 void *argp1 = 0 ;
41201 int res1 = 0 ;
41202 size_t val2 ;
41203 int ecode2 = 0 ;
41204 PyObject * obj0 = 0 ;
41205 PyObject * obj1 = 0 ;
41206 char * kwnames[] = {
41207 (char *) "self",(char *) "pos", NULL
41208 };
41209
41210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41212 if (!SWIG_IsOK(res1)) {
41213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41214 }
41215 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41216 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41217 if (!SWIG_IsOK(ecode2)) {
41218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41219 }
41220 arg2 = static_cast< size_t >(val2);
41221 {
41222 PyThreadState* __tstate = wxPyBeginAllowThreads();
41223 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41224 wxPyEndAllowThreads(__tstate);
41225 if (PyErr_Occurred()) SWIG_fail;
41226 }
41227 {
41228 resultobj = wxPyMake_wxObject(result, 0);
41229 }
41230 return resultobj;
41231 fail:
41232 return NULL;
41233 }
41234
41235
41236 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41237 PyObject *resultobj = 0;
41238 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41239 size_t arg2 ;
41240 wxMenu *arg3 = (wxMenu *) 0 ;
41241 wxString *arg4 = 0 ;
41242 wxMenu *result = 0 ;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 size_t val2 ;
41246 int ecode2 = 0 ;
41247 void *argp3 = 0 ;
41248 int res3 = 0 ;
41249 bool temp4 = false ;
41250 PyObject * obj0 = 0 ;
41251 PyObject * obj1 = 0 ;
41252 PyObject * obj2 = 0 ;
41253 PyObject * obj3 = 0 ;
41254 char * kwnames[] = {
41255 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41256 };
41257
41258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41260 if (!SWIG_IsOK(res1)) {
41261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41262 }
41263 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41264 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41265 if (!SWIG_IsOK(ecode2)) {
41266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41267 }
41268 arg2 = static_cast< size_t >(val2);
41269 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41270 if (!SWIG_IsOK(res3)) {
41271 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41272 }
41273 arg3 = reinterpret_cast< wxMenu * >(argp3);
41274 {
41275 arg4 = wxString_in_helper(obj3);
41276 if (arg4 == NULL) SWIG_fail;
41277 temp4 = true;
41278 }
41279 {
41280 PyThreadState* __tstate = wxPyBeginAllowThreads();
41281 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41282 wxPyEndAllowThreads(__tstate);
41283 if (PyErr_Occurred()) SWIG_fail;
41284 }
41285 {
41286 resultobj = wxPyMake_wxObject(result, 0);
41287 }
41288 {
41289 if (temp4)
41290 delete arg4;
41291 }
41292 return resultobj;
41293 fail:
41294 {
41295 if (temp4)
41296 delete arg4;
41297 }
41298 return NULL;
41299 }
41300
41301
41302 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41303 PyObject *resultobj = 0;
41304 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41305 size_t arg2 ;
41306 wxMenu *result = 0 ;
41307 void *argp1 = 0 ;
41308 int res1 = 0 ;
41309 size_t val2 ;
41310 int ecode2 = 0 ;
41311 PyObject * obj0 = 0 ;
41312 PyObject * obj1 = 0 ;
41313 char * kwnames[] = {
41314 (char *) "self",(char *) "pos", NULL
41315 };
41316
41317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41319 if (!SWIG_IsOK(res1)) {
41320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41321 }
41322 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41323 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41324 if (!SWIG_IsOK(ecode2)) {
41325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41326 }
41327 arg2 = static_cast< size_t >(val2);
41328 {
41329 PyThreadState* __tstate = wxPyBeginAllowThreads();
41330 result = (wxMenu *)(arg1)->Remove(arg2);
41331 wxPyEndAllowThreads(__tstate);
41332 if (PyErr_Occurred()) SWIG_fail;
41333 }
41334 {
41335 resultobj = wxPyMake_wxObject(result, 0);
41336 }
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41344 PyObject *resultobj = 0;
41345 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41346 size_t arg2 ;
41347 bool arg3 ;
41348 void *argp1 = 0 ;
41349 int res1 = 0 ;
41350 size_t val2 ;
41351 int ecode2 = 0 ;
41352 bool val3 ;
41353 int ecode3 = 0 ;
41354 PyObject * obj0 = 0 ;
41355 PyObject * obj1 = 0 ;
41356 PyObject * obj2 = 0 ;
41357 char * kwnames[] = {
41358 (char *) "self",(char *) "pos",(char *) "enable", NULL
41359 };
41360
41361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41363 if (!SWIG_IsOK(res1)) {
41364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41365 }
41366 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41367 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41368 if (!SWIG_IsOK(ecode2)) {
41369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41370 }
41371 arg2 = static_cast< size_t >(val2);
41372 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41373 if (!SWIG_IsOK(ecode3)) {
41374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41375 }
41376 arg3 = static_cast< bool >(val3);
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 (arg1)->EnableTop(arg2,arg3);
41380 wxPyEndAllowThreads(__tstate);
41381 if (PyErr_Occurred()) SWIG_fail;
41382 }
41383 resultobj = SWIG_Py_Void();
41384 return resultobj;
41385 fail:
41386 return NULL;
41387 }
41388
41389
41390 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41391 PyObject *resultobj = 0;
41392 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41393 size_t arg2 ;
41394 bool result;
41395 void *argp1 = 0 ;
41396 int res1 = 0 ;
41397 size_t val2 ;
41398 int ecode2 = 0 ;
41399 PyObject * obj0 = 0 ;
41400 PyObject * obj1 = 0 ;
41401 char * kwnames[] = {
41402 (char *) "self",(char *) "pos", NULL
41403 };
41404
41405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41407 if (!SWIG_IsOK(res1)) {
41408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41409 }
41410 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41411 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41412 if (!SWIG_IsOK(ecode2)) {
41413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41414 }
41415 arg2 = static_cast< size_t >(val2);
41416 {
41417 PyThreadState* __tstate = wxPyBeginAllowThreads();
41418 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41419 wxPyEndAllowThreads(__tstate);
41420 if (PyErr_Occurred()) SWIG_fail;
41421 }
41422 {
41423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41424 }
41425 return resultobj;
41426 fail:
41427 return NULL;
41428 }
41429
41430
41431 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj = 0;
41433 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41434 size_t arg2 ;
41435 wxString *arg3 = 0 ;
41436 void *argp1 = 0 ;
41437 int res1 = 0 ;
41438 size_t val2 ;
41439 int ecode2 = 0 ;
41440 bool temp3 = false ;
41441 PyObject * obj0 = 0 ;
41442 PyObject * obj1 = 0 ;
41443 PyObject * obj2 = 0 ;
41444 char * kwnames[] = {
41445 (char *) "self",(char *) "pos",(char *) "label", NULL
41446 };
41447
41448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41450 if (!SWIG_IsOK(res1)) {
41451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41452 }
41453 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41454 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41455 if (!SWIG_IsOK(ecode2)) {
41456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41457 }
41458 arg2 = static_cast< size_t >(val2);
41459 {
41460 arg3 = wxString_in_helper(obj2);
41461 if (arg3 == NULL) SWIG_fail;
41462 temp3 = true;
41463 }
41464 {
41465 PyThreadState* __tstate = wxPyBeginAllowThreads();
41466 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41467 wxPyEndAllowThreads(__tstate);
41468 if (PyErr_Occurred()) SWIG_fail;
41469 }
41470 resultobj = SWIG_Py_Void();
41471 {
41472 if (temp3)
41473 delete arg3;
41474 }
41475 return resultobj;
41476 fail:
41477 {
41478 if (temp3)
41479 delete arg3;
41480 }
41481 return NULL;
41482 }
41483
41484
41485 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41486 PyObject *resultobj = 0;
41487 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41488 size_t arg2 ;
41489 wxString result;
41490 void *argp1 = 0 ;
41491 int res1 = 0 ;
41492 size_t val2 ;
41493 int ecode2 = 0 ;
41494 PyObject * obj0 = 0 ;
41495 PyObject * obj1 = 0 ;
41496 char * kwnames[] = {
41497 (char *) "self",(char *) "pos", NULL
41498 };
41499
41500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41502 if (!SWIG_IsOK(res1)) {
41503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41504 }
41505 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41506 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41507 if (!SWIG_IsOK(ecode2)) {
41508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41509 }
41510 arg2 = static_cast< size_t >(val2);
41511 {
41512 PyThreadState* __tstate = wxPyBeginAllowThreads();
41513 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41514 wxPyEndAllowThreads(__tstate);
41515 if (PyErr_Occurred()) SWIG_fail;
41516 }
41517 {
41518 #if wxUSE_UNICODE
41519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41520 #else
41521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41522 #endif
41523 }
41524 return resultobj;
41525 fail:
41526 return NULL;
41527 }
41528
41529
41530 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41531 PyObject *resultobj = 0;
41532 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41533 wxString *arg2 = 0 ;
41534 wxString *arg3 = 0 ;
41535 int result;
41536 void *argp1 = 0 ;
41537 int res1 = 0 ;
41538 bool temp2 = false ;
41539 bool temp3 = false ;
41540 PyObject * obj0 = 0 ;
41541 PyObject * obj1 = 0 ;
41542 PyObject * obj2 = 0 ;
41543 char * kwnames[] = {
41544 (char *) "self",(char *) "menu",(char *) "item", NULL
41545 };
41546
41547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41549 if (!SWIG_IsOK(res1)) {
41550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41551 }
41552 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41553 {
41554 arg2 = wxString_in_helper(obj1);
41555 if (arg2 == NULL) SWIG_fail;
41556 temp2 = true;
41557 }
41558 {
41559 arg3 = wxString_in_helper(obj2);
41560 if (arg3 == NULL) SWIG_fail;
41561 temp3 = true;
41562 }
41563 {
41564 PyThreadState* __tstate = wxPyBeginAllowThreads();
41565 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41566 wxPyEndAllowThreads(__tstate);
41567 if (PyErr_Occurred()) SWIG_fail;
41568 }
41569 resultobj = SWIG_From_int(static_cast< int >(result));
41570 {
41571 if (temp2)
41572 delete arg2;
41573 }
41574 {
41575 if (temp3)
41576 delete arg3;
41577 }
41578 return resultobj;
41579 fail:
41580 {
41581 if (temp2)
41582 delete arg2;
41583 }
41584 {
41585 if (temp3)
41586 delete arg3;
41587 }
41588 return NULL;
41589 }
41590
41591
41592 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41593 PyObject *resultobj = 0;
41594 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41595 int arg2 ;
41596 wxMenuItem *result = 0 ;
41597 void *argp1 = 0 ;
41598 int res1 = 0 ;
41599 int val2 ;
41600 int ecode2 = 0 ;
41601 PyObject * obj0 = 0 ;
41602 PyObject * obj1 = 0 ;
41603 char * kwnames[] = {
41604 (char *) "self",(char *) "id", NULL
41605 };
41606
41607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41609 if (!SWIG_IsOK(res1)) {
41610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41611 }
41612 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41613 ecode2 = SWIG_AsVal_int(obj1, &val2);
41614 if (!SWIG_IsOK(ecode2)) {
41615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41616 }
41617 arg2 = static_cast< int >(val2);
41618 {
41619 PyThreadState* __tstate = wxPyBeginAllowThreads();
41620 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41621 wxPyEndAllowThreads(__tstate);
41622 if (PyErr_Occurred()) SWIG_fail;
41623 }
41624 {
41625 resultobj = wxPyMake_wxObject(result, (bool)0);
41626 }
41627 return resultobj;
41628 fail:
41629 return NULL;
41630 }
41631
41632
41633 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41634 PyObject *resultobj = 0;
41635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41636 wxString *arg2 = 0 ;
41637 int result;
41638 void *argp1 = 0 ;
41639 int res1 = 0 ;
41640 bool temp2 = false ;
41641 PyObject * obj0 = 0 ;
41642 PyObject * obj1 = 0 ;
41643 char * kwnames[] = {
41644 (char *) "self",(char *) "title", NULL
41645 };
41646
41647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41649 if (!SWIG_IsOK(res1)) {
41650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41651 }
41652 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41653 {
41654 arg2 = wxString_in_helper(obj1);
41655 if (arg2 == NULL) SWIG_fail;
41656 temp2 = true;
41657 }
41658 {
41659 PyThreadState* __tstate = wxPyBeginAllowThreads();
41660 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41661 wxPyEndAllowThreads(__tstate);
41662 if (PyErr_Occurred()) SWIG_fail;
41663 }
41664 resultobj = SWIG_From_int(static_cast< int >(result));
41665 {
41666 if (temp2)
41667 delete arg2;
41668 }
41669 return resultobj;
41670 fail:
41671 {
41672 if (temp2)
41673 delete arg2;
41674 }
41675 return NULL;
41676 }
41677
41678
41679 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41680 PyObject *resultobj = 0;
41681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41682 int arg2 ;
41683 bool arg3 ;
41684 void *argp1 = 0 ;
41685 int res1 = 0 ;
41686 int val2 ;
41687 int ecode2 = 0 ;
41688 bool val3 ;
41689 int ecode3 = 0 ;
41690 PyObject * obj0 = 0 ;
41691 PyObject * obj1 = 0 ;
41692 PyObject * obj2 = 0 ;
41693 char * kwnames[] = {
41694 (char *) "self",(char *) "id",(char *) "enable", NULL
41695 };
41696
41697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) 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_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41701 }
41702 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41703 ecode2 = SWIG_AsVal_int(obj1, &val2);
41704 if (!SWIG_IsOK(ecode2)) {
41705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41706 }
41707 arg2 = static_cast< int >(val2);
41708 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41709 if (!SWIG_IsOK(ecode3)) {
41710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41711 }
41712 arg3 = static_cast< bool >(val3);
41713 {
41714 PyThreadState* __tstate = wxPyBeginAllowThreads();
41715 (arg1)->Enable(arg2,arg3);
41716 wxPyEndAllowThreads(__tstate);
41717 if (PyErr_Occurred()) SWIG_fail;
41718 }
41719 resultobj = SWIG_Py_Void();
41720 return resultobj;
41721 fail:
41722 return NULL;
41723 }
41724
41725
41726 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41727 PyObject *resultobj = 0;
41728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41729 int arg2 ;
41730 bool arg3 ;
41731 void *argp1 = 0 ;
41732 int res1 = 0 ;
41733 int val2 ;
41734 int ecode2 = 0 ;
41735 bool val3 ;
41736 int ecode3 = 0 ;
41737 PyObject * obj0 = 0 ;
41738 PyObject * obj1 = 0 ;
41739 PyObject * obj2 = 0 ;
41740 char * kwnames[] = {
41741 (char *) "self",(char *) "id",(char *) "check", NULL
41742 };
41743
41744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",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_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41748 }
41749 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41750 ecode2 = SWIG_AsVal_int(obj1, &val2);
41751 if (!SWIG_IsOK(ecode2)) {
41752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41753 }
41754 arg2 = static_cast< int >(val2);
41755 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41756 if (!SWIG_IsOK(ecode3)) {
41757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41758 }
41759 arg3 = static_cast< bool >(val3);
41760 {
41761 PyThreadState* __tstate = wxPyBeginAllowThreads();
41762 (arg1)->Check(arg2,arg3);
41763 wxPyEndAllowThreads(__tstate);
41764 if (PyErr_Occurred()) SWIG_fail;
41765 }
41766 resultobj = SWIG_Py_Void();
41767 return resultobj;
41768 fail:
41769 return NULL;
41770 }
41771
41772
41773 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41774 PyObject *resultobj = 0;
41775 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41776 int arg2 ;
41777 bool result;
41778 void *argp1 = 0 ;
41779 int res1 = 0 ;
41780 int val2 ;
41781 int ecode2 = 0 ;
41782 PyObject * obj0 = 0 ;
41783 PyObject * obj1 = 0 ;
41784 char * kwnames[] = {
41785 (char *) "self",(char *) "id", NULL
41786 };
41787
41788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41790 if (!SWIG_IsOK(res1)) {
41791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41792 }
41793 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41794 ecode2 = SWIG_AsVal_int(obj1, &val2);
41795 if (!SWIG_IsOK(ecode2)) {
41796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41797 }
41798 arg2 = static_cast< int >(val2);
41799 {
41800 PyThreadState* __tstate = wxPyBeginAllowThreads();
41801 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41802 wxPyEndAllowThreads(__tstate);
41803 if (PyErr_Occurred()) SWIG_fail;
41804 }
41805 {
41806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41807 }
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41815 PyObject *resultobj = 0;
41816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41817 int arg2 ;
41818 bool result;
41819 void *argp1 = 0 ;
41820 int res1 = 0 ;
41821 int val2 ;
41822 int ecode2 = 0 ;
41823 PyObject * obj0 = 0 ;
41824 PyObject * obj1 = 0 ;
41825 char * kwnames[] = {
41826 (char *) "self",(char *) "id", NULL
41827 };
41828
41829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41831 if (!SWIG_IsOK(res1)) {
41832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41833 }
41834 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41835 ecode2 = SWIG_AsVal_int(obj1, &val2);
41836 if (!SWIG_IsOK(ecode2)) {
41837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41838 }
41839 arg2 = static_cast< int >(val2);
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 {
41847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41848 }
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj = 0;
41857 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41858 int arg2 ;
41859 wxString *arg3 = 0 ;
41860 void *argp1 = 0 ;
41861 int res1 = 0 ;
41862 int val2 ;
41863 int ecode2 = 0 ;
41864 bool temp3 = false ;
41865 PyObject * obj0 = 0 ;
41866 PyObject * obj1 = 0 ;
41867 PyObject * obj2 = 0 ;
41868 char * kwnames[] = {
41869 (char *) "self",(char *) "id",(char *) "label", NULL
41870 };
41871
41872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41874 if (!SWIG_IsOK(res1)) {
41875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41876 }
41877 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41878 ecode2 = SWIG_AsVal_int(obj1, &val2);
41879 if (!SWIG_IsOK(ecode2)) {
41880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41881 }
41882 arg2 = static_cast< int >(val2);
41883 {
41884 arg3 = wxString_in_helper(obj2);
41885 if (arg3 == NULL) SWIG_fail;
41886 temp3 = true;
41887 }
41888 {
41889 PyThreadState* __tstate = wxPyBeginAllowThreads();
41890 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41891 wxPyEndAllowThreads(__tstate);
41892 if (PyErr_Occurred()) SWIG_fail;
41893 }
41894 resultobj = SWIG_Py_Void();
41895 {
41896 if (temp3)
41897 delete arg3;
41898 }
41899 return resultobj;
41900 fail:
41901 {
41902 if (temp3)
41903 delete arg3;
41904 }
41905 return NULL;
41906 }
41907
41908
41909 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41910 PyObject *resultobj = 0;
41911 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41912 int arg2 ;
41913 wxString result;
41914 void *argp1 = 0 ;
41915 int res1 = 0 ;
41916 int val2 ;
41917 int ecode2 = 0 ;
41918 PyObject * obj0 = 0 ;
41919 PyObject * obj1 = 0 ;
41920 char * kwnames[] = {
41921 (char *) "self",(char *) "id", NULL
41922 };
41923
41924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41926 if (!SWIG_IsOK(res1)) {
41927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41928 }
41929 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41930 ecode2 = SWIG_AsVal_int(obj1, &val2);
41931 if (!SWIG_IsOK(ecode2)) {
41932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41933 }
41934 arg2 = static_cast< int >(val2);
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41938 wxPyEndAllowThreads(__tstate);
41939 if (PyErr_Occurred()) SWIG_fail;
41940 }
41941 {
41942 #if wxUSE_UNICODE
41943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41944 #else
41945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41946 #endif
41947 }
41948 return resultobj;
41949 fail:
41950 return NULL;
41951 }
41952
41953
41954 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41955 PyObject *resultobj = 0;
41956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41957 int arg2 ;
41958 wxString *arg3 = 0 ;
41959 void *argp1 = 0 ;
41960 int res1 = 0 ;
41961 int val2 ;
41962 int ecode2 = 0 ;
41963 bool temp3 = false ;
41964 PyObject * obj0 = 0 ;
41965 PyObject * obj1 = 0 ;
41966 PyObject * obj2 = 0 ;
41967 char * kwnames[] = {
41968 (char *) "self",(char *) "id",(char *) "helpString", NULL
41969 };
41970
41971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41973 if (!SWIG_IsOK(res1)) {
41974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41975 }
41976 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41977 ecode2 = SWIG_AsVal_int(obj1, &val2);
41978 if (!SWIG_IsOK(ecode2)) {
41979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41980 }
41981 arg2 = static_cast< int >(val2);
41982 {
41983 arg3 = wxString_in_helper(obj2);
41984 if (arg3 == NULL) SWIG_fail;
41985 temp3 = true;
41986 }
41987 {
41988 PyThreadState* __tstate = wxPyBeginAllowThreads();
41989 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41990 wxPyEndAllowThreads(__tstate);
41991 if (PyErr_Occurred()) SWIG_fail;
41992 }
41993 resultobj = SWIG_Py_Void();
41994 {
41995 if (temp3)
41996 delete arg3;
41997 }
41998 return resultobj;
41999 fail:
42000 {
42001 if (temp3)
42002 delete arg3;
42003 }
42004 return NULL;
42005 }
42006
42007
42008 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42009 PyObject *resultobj = 0;
42010 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42011 int arg2 ;
42012 wxString result;
42013 void *argp1 = 0 ;
42014 int res1 = 0 ;
42015 int val2 ;
42016 int ecode2 = 0 ;
42017 PyObject * obj0 = 0 ;
42018 PyObject * obj1 = 0 ;
42019 char * kwnames[] = {
42020 (char *) "self",(char *) "id", NULL
42021 };
42022
42023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42025 if (!SWIG_IsOK(res1)) {
42026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42027 }
42028 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42029 ecode2 = SWIG_AsVal_int(obj1, &val2);
42030 if (!SWIG_IsOK(ecode2)) {
42031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42032 }
42033 arg2 = static_cast< int >(val2);
42034 {
42035 PyThreadState* __tstate = wxPyBeginAllowThreads();
42036 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42037 wxPyEndAllowThreads(__tstate);
42038 if (PyErr_Occurred()) SWIG_fail;
42039 }
42040 {
42041 #if wxUSE_UNICODE
42042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42043 #else
42044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42045 #endif
42046 }
42047 return resultobj;
42048 fail:
42049 return NULL;
42050 }
42051
42052
42053 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42054 PyObject *resultobj = 0;
42055 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42056 wxFrame *result = 0 ;
42057 void *argp1 = 0 ;
42058 int res1 = 0 ;
42059 PyObject *swig_obj[1] ;
42060
42061 if (!args) SWIG_fail;
42062 swig_obj[0] = args;
42063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42064 if (!SWIG_IsOK(res1)) {
42065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42066 }
42067 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42068 {
42069 PyThreadState* __tstate = wxPyBeginAllowThreads();
42070 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42071 wxPyEndAllowThreads(__tstate);
42072 if (PyErr_Occurred()) SWIG_fail;
42073 }
42074 {
42075 resultobj = wxPyMake_wxObject(result, (bool)0);
42076 }
42077 return resultobj;
42078 fail:
42079 return NULL;
42080 }
42081
42082
42083 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42084 PyObject *resultobj = 0;
42085 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42086 bool result;
42087 void *argp1 = 0 ;
42088 int res1 = 0 ;
42089 PyObject *swig_obj[1] ;
42090
42091 if (!args) SWIG_fail;
42092 swig_obj[0] = args;
42093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42094 if (!SWIG_IsOK(res1)) {
42095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42096 }
42097 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42098 {
42099 PyThreadState* __tstate = wxPyBeginAllowThreads();
42100 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42101 wxPyEndAllowThreads(__tstate);
42102 if (PyErr_Occurred()) SWIG_fail;
42103 }
42104 {
42105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42106 }
42107 return resultobj;
42108 fail:
42109 return NULL;
42110 }
42111
42112
42113 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42114 PyObject *resultobj = 0;
42115 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42116 wxFrame *arg2 = (wxFrame *) 0 ;
42117 void *argp1 = 0 ;
42118 int res1 = 0 ;
42119 void *argp2 = 0 ;
42120 int res2 = 0 ;
42121 PyObject * obj0 = 0 ;
42122 PyObject * obj1 = 0 ;
42123 char * kwnames[] = {
42124 (char *) "self",(char *) "frame", NULL
42125 };
42126
42127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42129 if (!SWIG_IsOK(res1)) {
42130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42131 }
42132 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42133 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42134 if (!SWIG_IsOK(res2)) {
42135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42136 }
42137 arg2 = reinterpret_cast< wxFrame * >(argp2);
42138 {
42139 PyThreadState* __tstate = wxPyBeginAllowThreads();
42140 (arg1)->Attach(arg2);
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 resultobj = SWIG_Py_Void();
42145 return resultobj;
42146 fail:
42147 return NULL;
42148 }
42149
42150
42151 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42152 PyObject *resultobj = 0;
42153 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42154 void *argp1 = 0 ;
42155 int res1 = 0 ;
42156 PyObject *swig_obj[1] ;
42157
42158 if (!args) SWIG_fail;
42159 swig_obj[0] = args;
42160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42161 if (!SWIG_IsOK(res1)) {
42162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42163 }
42164 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42165 {
42166 PyThreadState* __tstate = wxPyBeginAllowThreads();
42167 (arg1)->Detach();
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 resultobj = SWIG_Py_Void();
42172 return resultobj;
42173 fail:
42174 return NULL;
42175 }
42176
42177
42178 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42179 PyObject *resultobj = 0;
42180 bool arg1 ;
42181 bool val1 ;
42182 int ecode1 = 0 ;
42183 PyObject * obj0 = 0 ;
42184 char * kwnames[] = {
42185 (char *) "enable", NULL
42186 };
42187
42188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42189 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42190 if (!SWIG_IsOK(ecode1)) {
42191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42192 }
42193 arg1 = static_cast< bool >(val1);
42194 {
42195 PyThreadState* __tstate = wxPyBeginAllowThreads();
42196 wxMenuBar_SetAutoWindowMenu(arg1);
42197 wxPyEndAllowThreads(__tstate);
42198 if (PyErr_Occurred()) SWIG_fail;
42199 }
42200 resultobj = SWIG_Py_Void();
42201 return resultobj;
42202 fail:
42203 return NULL;
42204 }
42205
42206
42207 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42208 PyObject *resultobj = 0;
42209 bool result;
42210
42211 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42212 {
42213 PyThreadState* __tstate = wxPyBeginAllowThreads();
42214 result = (bool)wxMenuBar_GetAutoWindowMenu();
42215 wxPyEndAllowThreads(__tstate);
42216 if (PyErr_Occurred()) SWIG_fail;
42217 }
42218 {
42219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42220 }
42221 return resultobj;
42222 fail:
42223 return NULL;
42224 }
42225
42226
42227 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42228 PyObject *obj;
42229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42230 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42231 return SWIG_Py_Void();
42232 }
42233
42234 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42235 return SWIG_Python_InitShadowInstance(args);
42236 }
42237
42238 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42239 PyObject *resultobj = 0;
42240 wxMenu *arg1 = (wxMenu *) NULL ;
42241 int arg2 = (int) wxID_ANY ;
42242 wxString const &arg3_defvalue = wxPyEmptyString ;
42243 wxString *arg3 = (wxString *) &arg3_defvalue ;
42244 wxString const &arg4_defvalue = wxPyEmptyString ;
42245 wxString *arg4 = (wxString *) &arg4_defvalue ;
42246 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42247 wxMenu *arg6 = (wxMenu *) NULL ;
42248 wxMenuItem *result = 0 ;
42249 void *argp1 = 0 ;
42250 int res1 = 0 ;
42251 int val2 ;
42252 int ecode2 = 0 ;
42253 bool temp3 = false ;
42254 bool temp4 = false ;
42255 int val5 ;
42256 int ecode5 = 0 ;
42257 void *argp6 = 0 ;
42258 int res6 = 0 ;
42259 PyObject * obj0 = 0 ;
42260 PyObject * obj1 = 0 ;
42261 PyObject * obj2 = 0 ;
42262 PyObject * obj3 = 0 ;
42263 PyObject * obj4 = 0 ;
42264 PyObject * obj5 = 0 ;
42265 char * kwnames[] = {
42266 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42267 };
42268
42269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42270 if (obj0) {
42271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42272 if (!SWIG_IsOK(res1)) {
42273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42274 }
42275 arg1 = reinterpret_cast< wxMenu * >(argp1);
42276 }
42277 if (obj1) {
42278 ecode2 = SWIG_AsVal_int(obj1, &val2);
42279 if (!SWIG_IsOK(ecode2)) {
42280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42281 }
42282 arg2 = static_cast< int >(val2);
42283 }
42284 if (obj2) {
42285 {
42286 arg3 = wxString_in_helper(obj2);
42287 if (arg3 == NULL) SWIG_fail;
42288 temp3 = true;
42289 }
42290 }
42291 if (obj3) {
42292 {
42293 arg4 = wxString_in_helper(obj3);
42294 if (arg4 == NULL) SWIG_fail;
42295 temp4 = true;
42296 }
42297 }
42298 if (obj4) {
42299 ecode5 = SWIG_AsVal_int(obj4, &val5);
42300 if (!SWIG_IsOK(ecode5)) {
42301 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42302 }
42303 arg5 = static_cast< wxItemKind >(val5);
42304 }
42305 if (obj5) {
42306 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42307 if (!SWIG_IsOK(res6)) {
42308 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42309 }
42310 arg6 = reinterpret_cast< wxMenu * >(argp6);
42311 }
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42315 wxPyEndAllowThreads(__tstate);
42316 if (PyErr_Occurred()) SWIG_fail;
42317 }
42318 {
42319 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42320 }
42321 {
42322 if (temp3)
42323 delete arg3;
42324 }
42325 {
42326 if (temp4)
42327 delete arg4;
42328 }
42329 return resultobj;
42330 fail:
42331 {
42332 if (temp3)
42333 delete arg3;
42334 }
42335 {
42336 if (temp4)
42337 delete arg4;
42338 }
42339 return NULL;
42340 }
42341
42342
42343 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42344 PyObject *resultobj = 0;
42345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42346 void *argp1 = 0 ;
42347 int res1 = 0 ;
42348 PyObject *swig_obj[1] ;
42349
42350 if (!args) SWIG_fail;
42351 swig_obj[0] = args;
42352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42353 if (!SWIG_IsOK(res1)) {
42354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42355 }
42356 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42357 {
42358 PyThreadState* __tstate = wxPyBeginAllowThreads();
42359 delete arg1;
42360
42361 wxPyEndAllowThreads(__tstate);
42362 if (PyErr_Occurred()) SWIG_fail;
42363 }
42364 resultobj = SWIG_Py_Void();
42365 return resultobj;
42366 fail:
42367 return NULL;
42368 }
42369
42370
42371 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42372 PyObject *resultobj = 0;
42373 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42374 wxMenu *result = 0 ;
42375 void *argp1 = 0 ;
42376 int res1 = 0 ;
42377 PyObject *swig_obj[1] ;
42378
42379 if (!args) SWIG_fail;
42380 swig_obj[0] = args;
42381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42382 if (!SWIG_IsOK(res1)) {
42383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42384 }
42385 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42386 {
42387 PyThreadState* __tstate = wxPyBeginAllowThreads();
42388 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42389 wxPyEndAllowThreads(__tstate);
42390 if (PyErr_Occurred()) SWIG_fail;
42391 }
42392 {
42393 resultobj = wxPyMake_wxObject(result, 0);
42394 }
42395 return resultobj;
42396 fail:
42397 return NULL;
42398 }
42399
42400
42401 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42402 PyObject *resultobj = 0;
42403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42404 wxMenu *arg2 = (wxMenu *) 0 ;
42405 void *argp1 = 0 ;
42406 int res1 = 0 ;
42407 void *argp2 = 0 ;
42408 int res2 = 0 ;
42409 PyObject * obj0 = 0 ;
42410 PyObject * obj1 = 0 ;
42411 char * kwnames[] = {
42412 (char *) "self",(char *) "menu", NULL
42413 };
42414
42415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42417 if (!SWIG_IsOK(res1)) {
42418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42419 }
42420 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42422 if (!SWIG_IsOK(res2)) {
42423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42424 }
42425 arg2 = reinterpret_cast< wxMenu * >(argp2);
42426 {
42427 PyThreadState* __tstate = wxPyBeginAllowThreads();
42428 (arg1)->SetMenu(arg2);
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 resultobj = SWIG_Py_Void();
42433 return resultobj;
42434 fail:
42435 return NULL;
42436 }
42437
42438
42439 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42440 PyObject *resultobj = 0;
42441 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42442 int arg2 ;
42443 void *argp1 = 0 ;
42444 int res1 = 0 ;
42445 int val2 ;
42446 int ecode2 = 0 ;
42447 PyObject * obj0 = 0 ;
42448 PyObject * obj1 = 0 ;
42449 char * kwnames[] = {
42450 (char *) "self",(char *) "id", NULL
42451 };
42452
42453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42455 if (!SWIG_IsOK(res1)) {
42456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42457 }
42458 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42459 ecode2 = SWIG_AsVal_int(obj1, &val2);
42460 if (!SWIG_IsOK(ecode2)) {
42461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42462 }
42463 arg2 = static_cast< int >(val2);
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 (arg1)->SetId(arg2);
42467 wxPyEndAllowThreads(__tstate);
42468 if (PyErr_Occurred()) SWIG_fail;
42469 }
42470 resultobj = SWIG_Py_Void();
42471 return resultobj;
42472 fail:
42473 return NULL;
42474 }
42475
42476
42477 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42478 PyObject *resultobj = 0;
42479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42480 int result;
42481 void *argp1 = 0 ;
42482 int res1 = 0 ;
42483 PyObject *swig_obj[1] ;
42484
42485 if (!args) SWIG_fail;
42486 swig_obj[0] = args;
42487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42488 if (!SWIG_IsOK(res1)) {
42489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42490 }
42491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42492 {
42493 PyThreadState* __tstate = wxPyBeginAllowThreads();
42494 result = (int)((wxMenuItem const *)arg1)->GetId();
42495 wxPyEndAllowThreads(__tstate);
42496 if (PyErr_Occurred()) SWIG_fail;
42497 }
42498 resultobj = SWIG_From_int(static_cast< int >(result));
42499 return resultobj;
42500 fail:
42501 return NULL;
42502 }
42503
42504
42505 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42506 PyObject *resultobj = 0;
42507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42508 bool result;
42509 void *argp1 = 0 ;
42510 int res1 = 0 ;
42511 PyObject *swig_obj[1] ;
42512
42513 if (!args) SWIG_fail;
42514 swig_obj[0] = args;
42515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42516 if (!SWIG_IsOK(res1)) {
42517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42518 }
42519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42520 {
42521 PyThreadState* __tstate = wxPyBeginAllowThreads();
42522 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42523 wxPyEndAllowThreads(__tstate);
42524 if (PyErr_Occurred()) SWIG_fail;
42525 }
42526 {
42527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42528 }
42529 return resultobj;
42530 fail:
42531 return NULL;
42532 }
42533
42534
42535 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42536 PyObject *resultobj = 0;
42537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42538 wxString *arg2 = 0 ;
42539 void *argp1 = 0 ;
42540 int res1 = 0 ;
42541 bool temp2 = false ;
42542 PyObject * obj0 = 0 ;
42543 PyObject * obj1 = 0 ;
42544 char * kwnames[] = {
42545 (char *) "self",(char *) "str", NULL
42546 };
42547
42548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42550 if (!SWIG_IsOK(res1)) {
42551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42552 }
42553 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42554 {
42555 arg2 = wxString_in_helper(obj1);
42556 if (arg2 == NULL) SWIG_fail;
42557 temp2 = true;
42558 }
42559 {
42560 PyThreadState* __tstate = wxPyBeginAllowThreads();
42561 (arg1)->SetText((wxString const &)*arg2);
42562 wxPyEndAllowThreads(__tstate);
42563 if (PyErr_Occurred()) SWIG_fail;
42564 }
42565 resultobj = SWIG_Py_Void();
42566 {
42567 if (temp2)
42568 delete arg2;
42569 }
42570 return resultobj;
42571 fail:
42572 {
42573 if (temp2)
42574 delete arg2;
42575 }
42576 return NULL;
42577 }
42578
42579
42580 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42581 PyObject *resultobj = 0;
42582 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42583 wxString result;
42584 void *argp1 = 0 ;
42585 int res1 = 0 ;
42586 PyObject *swig_obj[1] ;
42587
42588 if (!args) SWIG_fail;
42589 swig_obj[0] = args;
42590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42591 if (!SWIG_IsOK(res1)) {
42592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42593 }
42594 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42595 {
42596 PyThreadState* __tstate = wxPyBeginAllowThreads();
42597 result = ((wxMenuItem const *)arg1)->GetLabel();
42598 wxPyEndAllowThreads(__tstate);
42599 if (PyErr_Occurred()) SWIG_fail;
42600 }
42601 {
42602 #if wxUSE_UNICODE
42603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42604 #else
42605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42606 #endif
42607 }
42608 return resultobj;
42609 fail:
42610 return NULL;
42611 }
42612
42613
42614 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42615 PyObject *resultobj = 0;
42616 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42617 wxString *result = 0 ;
42618 void *argp1 = 0 ;
42619 int res1 = 0 ;
42620 PyObject *swig_obj[1] ;
42621
42622 if (!args) SWIG_fail;
42623 swig_obj[0] = args;
42624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42625 if (!SWIG_IsOK(res1)) {
42626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42627 }
42628 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42629 {
42630 PyThreadState* __tstate = wxPyBeginAllowThreads();
42631 {
42632 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42633 result = (wxString *) &_result_ref;
42634 }
42635 wxPyEndAllowThreads(__tstate);
42636 if (PyErr_Occurred()) SWIG_fail;
42637 }
42638 {
42639 #if wxUSE_UNICODE
42640 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42641 #else
42642 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42643 #endif
42644 }
42645 return resultobj;
42646 fail:
42647 return NULL;
42648 }
42649
42650
42651 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42652 PyObject *resultobj = 0;
42653 wxString *arg1 = 0 ;
42654 wxString result;
42655 bool temp1 = false ;
42656 PyObject * obj0 = 0 ;
42657 char * kwnames[] = {
42658 (char *) "text", NULL
42659 };
42660
42661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42662 {
42663 arg1 = wxString_in_helper(obj0);
42664 if (arg1 == NULL) SWIG_fail;
42665 temp1 = true;
42666 }
42667 {
42668 PyThreadState* __tstate = wxPyBeginAllowThreads();
42669 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42670 wxPyEndAllowThreads(__tstate);
42671 if (PyErr_Occurred()) SWIG_fail;
42672 }
42673 {
42674 #if wxUSE_UNICODE
42675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42676 #else
42677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42678 #endif
42679 }
42680 {
42681 if (temp1)
42682 delete arg1;
42683 }
42684 return resultobj;
42685 fail:
42686 {
42687 if (temp1)
42688 delete arg1;
42689 }
42690 return NULL;
42691 }
42692
42693
42694 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42695 PyObject *resultobj = 0;
42696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42697 wxItemKind result;
42698 void *argp1 = 0 ;
42699 int res1 = 0 ;
42700 PyObject *swig_obj[1] ;
42701
42702 if (!args) SWIG_fail;
42703 swig_obj[0] = args;
42704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42705 if (!SWIG_IsOK(res1)) {
42706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42707 }
42708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42709 {
42710 PyThreadState* __tstate = wxPyBeginAllowThreads();
42711 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42712 wxPyEndAllowThreads(__tstate);
42713 if (PyErr_Occurred()) SWIG_fail;
42714 }
42715 resultobj = SWIG_From_int(static_cast< int >(result));
42716 return resultobj;
42717 fail:
42718 return NULL;
42719 }
42720
42721
42722 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42723 PyObject *resultobj = 0;
42724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42725 wxItemKind arg2 ;
42726 void *argp1 = 0 ;
42727 int res1 = 0 ;
42728 int val2 ;
42729 int ecode2 = 0 ;
42730 PyObject * obj0 = 0 ;
42731 PyObject * obj1 = 0 ;
42732 char * kwnames[] = {
42733 (char *) "self",(char *) "kind", NULL
42734 };
42735
42736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42738 if (!SWIG_IsOK(res1)) {
42739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42740 }
42741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42742 ecode2 = SWIG_AsVal_int(obj1, &val2);
42743 if (!SWIG_IsOK(ecode2)) {
42744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42745 }
42746 arg2 = static_cast< wxItemKind >(val2);
42747 {
42748 PyThreadState* __tstate = wxPyBeginAllowThreads();
42749 (arg1)->SetKind(arg2);
42750 wxPyEndAllowThreads(__tstate);
42751 if (PyErr_Occurred()) SWIG_fail;
42752 }
42753 resultobj = SWIG_Py_Void();
42754 return resultobj;
42755 fail:
42756 return NULL;
42757 }
42758
42759
42760 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42761 PyObject *resultobj = 0;
42762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42763 bool arg2 ;
42764 void *argp1 = 0 ;
42765 int res1 = 0 ;
42766 bool val2 ;
42767 int ecode2 = 0 ;
42768 PyObject * obj0 = 0 ;
42769 PyObject * obj1 = 0 ;
42770 char * kwnames[] = {
42771 (char *) "self",(char *) "checkable", NULL
42772 };
42773
42774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42776 if (!SWIG_IsOK(res1)) {
42777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42778 }
42779 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42781 if (!SWIG_IsOK(ecode2)) {
42782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42783 }
42784 arg2 = static_cast< bool >(val2);
42785 {
42786 PyThreadState* __tstate = wxPyBeginAllowThreads();
42787 (arg1)->SetCheckable(arg2);
42788 wxPyEndAllowThreads(__tstate);
42789 if (PyErr_Occurred()) SWIG_fail;
42790 }
42791 resultobj = SWIG_Py_Void();
42792 return resultobj;
42793 fail:
42794 return NULL;
42795 }
42796
42797
42798 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42799 PyObject *resultobj = 0;
42800 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42801 bool result;
42802 void *argp1 = 0 ;
42803 int res1 = 0 ;
42804 PyObject *swig_obj[1] ;
42805
42806 if (!args) SWIG_fail;
42807 swig_obj[0] = args;
42808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42809 if (!SWIG_IsOK(res1)) {
42810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42811 }
42812 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42813 {
42814 PyThreadState* __tstate = wxPyBeginAllowThreads();
42815 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42816 wxPyEndAllowThreads(__tstate);
42817 if (PyErr_Occurred()) SWIG_fail;
42818 }
42819 {
42820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42821 }
42822 return resultobj;
42823 fail:
42824 return NULL;
42825 }
42826
42827
42828 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42829 PyObject *resultobj = 0;
42830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42831 bool result;
42832 void *argp1 = 0 ;
42833 int res1 = 0 ;
42834 PyObject *swig_obj[1] ;
42835
42836 if (!args) SWIG_fail;
42837 swig_obj[0] = args;
42838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42839 if (!SWIG_IsOK(res1)) {
42840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42841 }
42842 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42843 {
42844 PyThreadState* __tstate = wxPyBeginAllowThreads();
42845 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42846 wxPyEndAllowThreads(__tstate);
42847 if (PyErr_Occurred()) SWIG_fail;
42848 }
42849 {
42850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42851 }
42852 return resultobj;
42853 fail:
42854 return NULL;
42855 }
42856
42857
42858 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42859 PyObject *resultobj = 0;
42860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42861 wxMenu *arg2 = (wxMenu *) 0 ;
42862 void *argp1 = 0 ;
42863 int res1 = 0 ;
42864 void *argp2 = 0 ;
42865 int res2 = 0 ;
42866 PyObject * obj0 = 0 ;
42867 PyObject * obj1 = 0 ;
42868 char * kwnames[] = {
42869 (char *) "self",(char *) "menu", NULL
42870 };
42871
42872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42874 if (!SWIG_IsOK(res1)) {
42875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42876 }
42877 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42878 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42879 if (!SWIG_IsOK(res2)) {
42880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42881 }
42882 arg2 = reinterpret_cast< wxMenu * >(argp2);
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 (arg1)->SetSubMenu(arg2);
42886 wxPyEndAllowThreads(__tstate);
42887 if (PyErr_Occurred()) SWIG_fail;
42888 }
42889 resultobj = SWIG_Py_Void();
42890 return resultobj;
42891 fail:
42892 return NULL;
42893 }
42894
42895
42896 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42897 PyObject *resultobj = 0;
42898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42899 wxMenu *result = 0 ;
42900 void *argp1 = 0 ;
42901 int res1 = 0 ;
42902 PyObject *swig_obj[1] ;
42903
42904 if (!args) SWIG_fail;
42905 swig_obj[0] = args;
42906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42907 if (!SWIG_IsOK(res1)) {
42908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42909 }
42910 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42911 {
42912 PyThreadState* __tstate = wxPyBeginAllowThreads();
42913 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 {
42918 resultobj = wxPyMake_wxObject(result, 0);
42919 }
42920 return resultobj;
42921 fail:
42922 return NULL;
42923 }
42924
42925
42926 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42927 PyObject *resultobj = 0;
42928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42929 bool arg2 = (bool) true ;
42930 void *argp1 = 0 ;
42931 int res1 = 0 ;
42932 bool val2 ;
42933 int ecode2 = 0 ;
42934 PyObject * obj0 = 0 ;
42935 PyObject * obj1 = 0 ;
42936 char * kwnames[] = {
42937 (char *) "self",(char *) "enable", NULL
42938 };
42939
42940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42942 if (!SWIG_IsOK(res1)) {
42943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42944 }
42945 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42946 if (obj1) {
42947 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42948 if (!SWIG_IsOK(ecode2)) {
42949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42950 }
42951 arg2 = static_cast< bool >(val2);
42952 }
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 (arg1)->Enable(arg2);
42956 wxPyEndAllowThreads(__tstate);
42957 if (PyErr_Occurred()) SWIG_fail;
42958 }
42959 resultobj = SWIG_Py_Void();
42960 return resultobj;
42961 fail:
42962 return NULL;
42963 }
42964
42965
42966 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42967 PyObject *resultobj = 0;
42968 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42969 bool result;
42970 void *argp1 = 0 ;
42971 int res1 = 0 ;
42972 PyObject *swig_obj[1] ;
42973
42974 if (!args) SWIG_fail;
42975 swig_obj[0] = args;
42976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42977 if (!SWIG_IsOK(res1)) {
42978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42979 }
42980 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42981 {
42982 PyThreadState* __tstate = wxPyBeginAllowThreads();
42983 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42984 wxPyEndAllowThreads(__tstate);
42985 if (PyErr_Occurred()) SWIG_fail;
42986 }
42987 {
42988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42989 }
42990 return resultobj;
42991 fail:
42992 return NULL;
42993 }
42994
42995
42996 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42997 PyObject *resultobj = 0;
42998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42999 bool arg2 = (bool) true ;
43000 void *argp1 = 0 ;
43001 int res1 = 0 ;
43002 bool val2 ;
43003 int ecode2 = 0 ;
43004 PyObject * obj0 = 0 ;
43005 PyObject * obj1 = 0 ;
43006 char * kwnames[] = {
43007 (char *) "self",(char *) "check", NULL
43008 };
43009
43010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43012 if (!SWIG_IsOK(res1)) {
43013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43014 }
43015 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43016 if (obj1) {
43017 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43018 if (!SWIG_IsOK(ecode2)) {
43019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43020 }
43021 arg2 = static_cast< bool >(val2);
43022 }
43023 {
43024 PyThreadState* __tstate = wxPyBeginAllowThreads();
43025 (arg1)->Check(arg2);
43026 wxPyEndAllowThreads(__tstate);
43027 if (PyErr_Occurred()) SWIG_fail;
43028 }
43029 resultobj = SWIG_Py_Void();
43030 return resultobj;
43031 fail:
43032 return NULL;
43033 }
43034
43035
43036 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43037 PyObject *resultobj = 0;
43038 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43039 bool result;
43040 void *argp1 = 0 ;
43041 int res1 = 0 ;
43042 PyObject *swig_obj[1] ;
43043
43044 if (!args) SWIG_fail;
43045 swig_obj[0] = args;
43046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43047 if (!SWIG_IsOK(res1)) {
43048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43049 }
43050 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43051 {
43052 PyThreadState* __tstate = wxPyBeginAllowThreads();
43053 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43054 wxPyEndAllowThreads(__tstate);
43055 if (PyErr_Occurred()) SWIG_fail;
43056 }
43057 {
43058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43059 }
43060 return resultobj;
43061 fail:
43062 return NULL;
43063 }
43064
43065
43066 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43067 PyObject *resultobj = 0;
43068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43069 void *argp1 = 0 ;
43070 int res1 = 0 ;
43071 PyObject *swig_obj[1] ;
43072
43073 if (!args) SWIG_fail;
43074 swig_obj[0] = args;
43075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43076 if (!SWIG_IsOK(res1)) {
43077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43078 }
43079 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43080 {
43081 PyThreadState* __tstate = wxPyBeginAllowThreads();
43082 (arg1)->Toggle();
43083 wxPyEndAllowThreads(__tstate);
43084 if (PyErr_Occurred()) SWIG_fail;
43085 }
43086 resultobj = SWIG_Py_Void();
43087 return resultobj;
43088 fail:
43089 return NULL;
43090 }
43091
43092
43093 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43094 PyObject *resultobj = 0;
43095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43096 wxString *arg2 = 0 ;
43097 void *argp1 = 0 ;
43098 int res1 = 0 ;
43099 bool temp2 = false ;
43100 PyObject * obj0 = 0 ;
43101 PyObject * obj1 = 0 ;
43102 char * kwnames[] = {
43103 (char *) "self",(char *) "str", NULL
43104 };
43105
43106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43108 if (!SWIG_IsOK(res1)) {
43109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43110 }
43111 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43112 {
43113 arg2 = wxString_in_helper(obj1);
43114 if (arg2 == NULL) SWIG_fail;
43115 temp2 = true;
43116 }
43117 {
43118 PyThreadState* __tstate = wxPyBeginAllowThreads();
43119 (arg1)->SetHelp((wxString const &)*arg2);
43120 wxPyEndAllowThreads(__tstate);
43121 if (PyErr_Occurred()) SWIG_fail;
43122 }
43123 resultobj = SWIG_Py_Void();
43124 {
43125 if (temp2)
43126 delete arg2;
43127 }
43128 return resultobj;
43129 fail:
43130 {
43131 if (temp2)
43132 delete arg2;
43133 }
43134 return NULL;
43135 }
43136
43137
43138 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43139 PyObject *resultobj = 0;
43140 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43141 wxString *result = 0 ;
43142 void *argp1 = 0 ;
43143 int res1 = 0 ;
43144 PyObject *swig_obj[1] ;
43145
43146 if (!args) SWIG_fail;
43147 swig_obj[0] = args;
43148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43149 if (!SWIG_IsOK(res1)) {
43150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43151 }
43152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43153 {
43154 PyThreadState* __tstate = wxPyBeginAllowThreads();
43155 {
43156 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43157 result = (wxString *) &_result_ref;
43158 }
43159 wxPyEndAllowThreads(__tstate);
43160 if (PyErr_Occurred()) SWIG_fail;
43161 }
43162 {
43163 #if wxUSE_UNICODE
43164 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43165 #else
43166 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43167 #endif
43168 }
43169 return resultobj;
43170 fail:
43171 return NULL;
43172 }
43173
43174
43175 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43176 PyObject *resultobj = 0;
43177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43178 wxAcceleratorEntry *result = 0 ;
43179 void *argp1 = 0 ;
43180 int res1 = 0 ;
43181 PyObject *swig_obj[1] ;
43182
43183 if (!args) SWIG_fail;
43184 swig_obj[0] = args;
43185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43186 if (!SWIG_IsOK(res1)) {
43187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43188 }
43189 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43190 {
43191 PyThreadState* __tstate = wxPyBeginAllowThreads();
43192 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43193 wxPyEndAllowThreads(__tstate);
43194 if (PyErr_Occurred()) SWIG_fail;
43195 }
43196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43197 return resultobj;
43198 fail:
43199 return NULL;
43200 }
43201
43202
43203 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43204 PyObject *resultobj = 0;
43205 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43206 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43207 void *argp1 = 0 ;
43208 int res1 = 0 ;
43209 void *argp2 = 0 ;
43210 int res2 = 0 ;
43211 PyObject * obj0 = 0 ;
43212 PyObject * obj1 = 0 ;
43213 char * kwnames[] = {
43214 (char *) "self",(char *) "accel", NULL
43215 };
43216
43217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43219 if (!SWIG_IsOK(res1)) {
43220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43221 }
43222 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43224 if (!SWIG_IsOK(res2)) {
43225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43226 }
43227 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43228 {
43229 PyThreadState* __tstate = wxPyBeginAllowThreads();
43230 (arg1)->SetAccel(arg2);
43231 wxPyEndAllowThreads(__tstate);
43232 if (PyErr_Occurred()) SWIG_fail;
43233 }
43234 resultobj = SWIG_Py_Void();
43235 return resultobj;
43236 fail:
43237 return NULL;
43238 }
43239
43240
43241 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43242 PyObject *resultobj = 0;
43243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43244 wxBitmap *arg2 = 0 ;
43245 void *argp1 = 0 ;
43246 int res1 = 0 ;
43247 void *argp2 = 0 ;
43248 int res2 = 0 ;
43249 PyObject * obj0 = 0 ;
43250 PyObject * obj1 = 0 ;
43251 char * kwnames[] = {
43252 (char *) "self",(char *) "bitmap", NULL
43253 };
43254
43255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43257 if (!SWIG_IsOK(res1)) {
43258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43259 }
43260 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43261 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43262 if (!SWIG_IsOK(res2)) {
43263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43264 }
43265 if (!argp2) {
43266 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43267 }
43268 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43269 {
43270 PyThreadState* __tstate = wxPyBeginAllowThreads();
43271 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43272 wxPyEndAllowThreads(__tstate);
43273 if (PyErr_Occurred()) SWIG_fail;
43274 }
43275 resultobj = SWIG_Py_Void();
43276 return resultobj;
43277 fail:
43278 return NULL;
43279 }
43280
43281
43282 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43283 PyObject *resultobj = 0;
43284 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43285 wxBitmap *result = 0 ;
43286 void *argp1 = 0 ;
43287 int res1 = 0 ;
43288 PyObject *swig_obj[1] ;
43289
43290 if (!args) SWIG_fail;
43291 swig_obj[0] = args;
43292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43293 if (!SWIG_IsOK(res1)) {
43294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43295 }
43296 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43297 {
43298 PyThreadState* __tstate = wxPyBeginAllowThreads();
43299 {
43300 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43301 result = (wxBitmap *) &_result_ref;
43302 }
43303 wxPyEndAllowThreads(__tstate);
43304 if (PyErr_Occurred()) SWIG_fail;
43305 }
43306 {
43307 wxBitmap* resultptr = new wxBitmap(*result);
43308 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43309 }
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43317 PyObject *resultobj = 0;
43318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43319 wxFont *arg2 = 0 ;
43320 void *argp1 = 0 ;
43321 int res1 = 0 ;
43322 void *argp2 = 0 ;
43323 int res2 = 0 ;
43324 PyObject * obj0 = 0 ;
43325 PyObject * obj1 = 0 ;
43326 char * kwnames[] = {
43327 (char *) "self",(char *) "font", NULL
43328 };
43329
43330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",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_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43334 }
43335 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43337 if (!SWIG_IsOK(res2)) {
43338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43339 }
43340 if (!argp2) {
43341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43342 }
43343 arg2 = reinterpret_cast< wxFont * >(argp2);
43344 {
43345 PyThreadState* __tstate = wxPyBeginAllowThreads();
43346 (arg1)->SetFont((wxFont const &)*arg2);
43347 wxPyEndAllowThreads(__tstate);
43348 if (PyErr_Occurred()) SWIG_fail;
43349 }
43350 resultobj = SWIG_Py_Void();
43351 return resultobj;
43352 fail:
43353 return NULL;
43354 }
43355
43356
43357 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43358 PyObject *resultobj = 0;
43359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43360 wxFont result;
43361 void *argp1 = 0 ;
43362 int res1 = 0 ;
43363 PyObject *swig_obj[1] ;
43364
43365 if (!args) SWIG_fail;
43366 swig_obj[0] = args;
43367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43368 if (!SWIG_IsOK(res1)) {
43369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43370 }
43371 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43372 {
43373 PyThreadState* __tstate = wxPyBeginAllowThreads();
43374 result = (arg1)->GetFont();
43375 wxPyEndAllowThreads(__tstate);
43376 if (PyErr_Occurred()) SWIG_fail;
43377 }
43378 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43379 return resultobj;
43380 fail:
43381 return NULL;
43382 }
43383
43384
43385 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43386 PyObject *resultobj = 0;
43387 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43388 wxColour *arg2 = 0 ;
43389 void *argp1 = 0 ;
43390 int res1 = 0 ;
43391 wxColour temp2 ;
43392 PyObject * obj0 = 0 ;
43393 PyObject * obj1 = 0 ;
43394 char * kwnames[] = {
43395 (char *) "self",(char *) "colText", NULL
43396 };
43397
43398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43400 if (!SWIG_IsOK(res1)) {
43401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43402 }
43403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43404 {
43405 arg2 = &temp2;
43406 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43407 }
43408 {
43409 PyThreadState* __tstate = wxPyBeginAllowThreads();
43410 (arg1)->SetTextColour((wxColour const &)*arg2);
43411 wxPyEndAllowThreads(__tstate);
43412 if (PyErr_Occurred()) SWIG_fail;
43413 }
43414 resultobj = SWIG_Py_Void();
43415 return resultobj;
43416 fail:
43417 return NULL;
43418 }
43419
43420
43421 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43422 PyObject *resultobj = 0;
43423 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43424 wxColour result;
43425 void *argp1 = 0 ;
43426 int res1 = 0 ;
43427 PyObject *swig_obj[1] ;
43428
43429 if (!args) SWIG_fail;
43430 swig_obj[0] = args;
43431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43432 if (!SWIG_IsOK(res1)) {
43433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43434 }
43435 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43436 {
43437 PyThreadState* __tstate = wxPyBeginAllowThreads();
43438 result = (arg1)->GetTextColour();
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43443 return resultobj;
43444 fail:
43445 return NULL;
43446 }
43447
43448
43449 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43450 PyObject *resultobj = 0;
43451 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43452 wxColour *arg2 = 0 ;
43453 void *argp1 = 0 ;
43454 int res1 = 0 ;
43455 wxColour temp2 ;
43456 PyObject * obj0 = 0 ;
43457 PyObject * obj1 = 0 ;
43458 char * kwnames[] = {
43459 (char *) "self",(char *) "colBack", NULL
43460 };
43461
43462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43464 if (!SWIG_IsOK(res1)) {
43465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43466 }
43467 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43468 {
43469 arg2 = &temp2;
43470 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43471 }
43472 {
43473 PyThreadState* __tstate = wxPyBeginAllowThreads();
43474 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43475 wxPyEndAllowThreads(__tstate);
43476 if (PyErr_Occurred()) SWIG_fail;
43477 }
43478 resultobj = SWIG_Py_Void();
43479 return resultobj;
43480 fail:
43481 return NULL;
43482 }
43483
43484
43485 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43486 PyObject *resultobj = 0;
43487 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43488 wxColour result;
43489 void *argp1 = 0 ;
43490 int res1 = 0 ;
43491 PyObject *swig_obj[1] ;
43492
43493 if (!args) SWIG_fail;
43494 swig_obj[0] = args;
43495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43496 if (!SWIG_IsOK(res1)) {
43497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43498 }
43499 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 result = (arg1)->GetBackgroundColour();
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43507 return resultobj;
43508 fail:
43509 return NULL;
43510 }
43511
43512
43513 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43514 PyObject *resultobj = 0;
43515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43516 wxBitmap *arg2 = 0 ;
43517 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43518 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43519 void *argp1 = 0 ;
43520 int res1 = 0 ;
43521 void *argp2 = 0 ;
43522 int res2 = 0 ;
43523 void *argp3 = 0 ;
43524 int res3 = 0 ;
43525 PyObject * obj0 = 0 ;
43526 PyObject * obj1 = 0 ;
43527 PyObject * obj2 = 0 ;
43528 char * kwnames[] = {
43529 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43530 };
43531
43532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43534 if (!SWIG_IsOK(res1)) {
43535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43536 }
43537 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43539 if (!SWIG_IsOK(res2)) {
43540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43541 }
43542 if (!argp2) {
43543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43544 }
43545 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43546 if (obj2) {
43547 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43548 if (!SWIG_IsOK(res3)) {
43549 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43550 }
43551 if (!argp3) {
43552 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43553 }
43554 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43555 }
43556 {
43557 PyThreadState* __tstate = wxPyBeginAllowThreads();
43558 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43559 wxPyEndAllowThreads(__tstate);
43560 if (PyErr_Occurred()) SWIG_fail;
43561 }
43562 resultobj = SWIG_Py_Void();
43563 return resultobj;
43564 fail:
43565 return NULL;
43566 }
43567
43568
43569 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43570 PyObject *resultobj = 0;
43571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43572 wxBitmap *arg2 = 0 ;
43573 void *argp1 = 0 ;
43574 int res1 = 0 ;
43575 void *argp2 = 0 ;
43576 int res2 = 0 ;
43577 PyObject * obj0 = 0 ;
43578 PyObject * obj1 = 0 ;
43579 char * kwnames[] = {
43580 (char *) "self",(char *) "bmpDisabled", NULL
43581 };
43582
43583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43585 if (!SWIG_IsOK(res1)) {
43586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43587 }
43588 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43589 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43590 if (!SWIG_IsOK(res2)) {
43591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43592 }
43593 if (!argp2) {
43594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43595 }
43596 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43597 {
43598 PyThreadState* __tstate = wxPyBeginAllowThreads();
43599 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43600 wxPyEndAllowThreads(__tstate);
43601 if (PyErr_Occurred()) SWIG_fail;
43602 }
43603 resultobj = SWIG_Py_Void();
43604 return resultobj;
43605 fail:
43606 return NULL;
43607 }
43608
43609
43610 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43611 PyObject *resultobj = 0;
43612 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43613 wxBitmap *result = 0 ;
43614 void *argp1 = 0 ;
43615 int res1 = 0 ;
43616 PyObject *swig_obj[1] ;
43617
43618 if (!args) SWIG_fail;
43619 swig_obj[0] = args;
43620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43621 if (!SWIG_IsOK(res1)) {
43622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43623 }
43624 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43625 {
43626 PyThreadState* __tstate = wxPyBeginAllowThreads();
43627 {
43628 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43629 result = (wxBitmap *) &_result_ref;
43630 }
43631 wxPyEndAllowThreads(__tstate);
43632 if (PyErr_Occurred()) SWIG_fail;
43633 }
43634 {
43635 wxBitmap* resultptr = new wxBitmap(*result);
43636 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43637 }
43638 return resultobj;
43639 fail:
43640 return NULL;
43641 }
43642
43643
43644 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43645 PyObject *resultobj = 0;
43646 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43647 int arg2 ;
43648 void *argp1 = 0 ;
43649 int res1 = 0 ;
43650 int val2 ;
43651 int ecode2 = 0 ;
43652 PyObject * obj0 = 0 ;
43653 PyObject * obj1 = 0 ;
43654 char * kwnames[] = {
43655 (char *) "self",(char *) "nWidth", NULL
43656 };
43657
43658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43660 if (!SWIG_IsOK(res1)) {
43661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43662 }
43663 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43664 ecode2 = SWIG_AsVal_int(obj1, &val2);
43665 if (!SWIG_IsOK(ecode2)) {
43666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43667 }
43668 arg2 = static_cast< int >(val2);
43669 {
43670 PyThreadState* __tstate = wxPyBeginAllowThreads();
43671 (arg1)->SetMarginWidth(arg2);
43672 wxPyEndAllowThreads(__tstate);
43673 if (PyErr_Occurred()) SWIG_fail;
43674 }
43675 resultobj = SWIG_Py_Void();
43676 return resultobj;
43677 fail:
43678 return NULL;
43679 }
43680
43681
43682 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43683 PyObject *resultobj = 0;
43684 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43685 int result;
43686 void *argp1 = 0 ;
43687 int res1 = 0 ;
43688 PyObject *swig_obj[1] ;
43689
43690 if (!args) SWIG_fail;
43691 swig_obj[0] = args;
43692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43693 if (!SWIG_IsOK(res1)) {
43694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43695 }
43696 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43697 {
43698 PyThreadState* __tstate = wxPyBeginAllowThreads();
43699 result = (int)(arg1)->GetMarginWidth();
43700 wxPyEndAllowThreads(__tstate);
43701 if (PyErr_Occurred()) SWIG_fail;
43702 }
43703 resultobj = SWIG_From_int(static_cast< int >(result));
43704 return resultobj;
43705 fail:
43706 return NULL;
43707 }
43708
43709
43710 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43711 PyObject *resultobj = 0;
43712 int result;
43713
43714 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43715 {
43716 PyThreadState* __tstate = wxPyBeginAllowThreads();
43717 result = (int)wxMenuItem::GetDefaultMarginWidth();
43718 wxPyEndAllowThreads(__tstate);
43719 if (PyErr_Occurred()) SWIG_fail;
43720 }
43721 resultobj = SWIG_From_int(static_cast< int >(result));
43722 return resultobj;
43723 fail:
43724 return NULL;
43725 }
43726
43727
43728 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43729 PyObject *resultobj = 0;
43730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43731 bool result;
43732 void *argp1 = 0 ;
43733 int res1 = 0 ;
43734 PyObject *swig_obj[1] ;
43735
43736 if (!args) SWIG_fail;
43737 swig_obj[0] = args;
43738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43739 if (!SWIG_IsOK(res1)) {
43740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43741 }
43742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43743 {
43744 PyThreadState* __tstate = wxPyBeginAllowThreads();
43745 result = (bool)(arg1)->IsOwnerDrawn();
43746 wxPyEndAllowThreads(__tstate);
43747 if (PyErr_Occurred()) SWIG_fail;
43748 }
43749 {
43750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43751 }
43752 return resultobj;
43753 fail:
43754 return NULL;
43755 }
43756
43757
43758 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43759 PyObject *resultobj = 0;
43760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43761 bool arg2 = (bool) true ;
43762 void *argp1 = 0 ;
43763 int res1 = 0 ;
43764 bool val2 ;
43765 int ecode2 = 0 ;
43766 PyObject * obj0 = 0 ;
43767 PyObject * obj1 = 0 ;
43768 char * kwnames[] = {
43769 (char *) "self",(char *) "ownerDrawn", NULL
43770 };
43771
43772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43774 if (!SWIG_IsOK(res1)) {
43775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43776 }
43777 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43778 if (obj1) {
43779 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43780 if (!SWIG_IsOK(ecode2)) {
43781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43782 }
43783 arg2 = static_cast< bool >(val2);
43784 }
43785 {
43786 PyThreadState* __tstate = wxPyBeginAllowThreads();
43787 (arg1)->SetOwnerDrawn(arg2);
43788 wxPyEndAllowThreads(__tstate);
43789 if (PyErr_Occurred()) SWIG_fail;
43790 }
43791 resultobj = SWIG_Py_Void();
43792 return resultobj;
43793 fail:
43794 return NULL;
43795 }
43796
43797
43798 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43799 PyObject *resultobj = 0;
43800 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43801 void *argp1 = 0 ;
43802 int res1 = 0 ;
43803 PyObject *swig_obj[1] ;
43804
43805 if (!args) SWIG_fail;
43806 swig_obj[0] = args;
43807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43808 if (!SWIG_IsOK(res1)) {
43809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43810 }
43811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43812 {
43813 PyThreadState* __tstate = wxPyBeginAllowThreads();
43814 (arg1)->ResetOwnerDrawn();
43815 wxPyEndAllowThreads(__tstate);
43816 if (PyErr_Occurred()) SWIG_fail;
43817 }
43818 resultobj = SWIG_Py_Void();
43819 return resultobj;
43820 fail:
43821 return NULL;
43822 }
43823
43824
43825 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43826 PyObject *obj;
43827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43828 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43829 return SWIG_Py_Void();
43830 }
43831
43832 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43833 return SWIG_Python_InitShadowInstance(args);
43834 }
43835
43836 SWIGINTERN int ControlNameStr_set(PyObject *) {
43837 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43838 return 1;
43839 }
43840
43841
43842 SWIGINTERN PyObject *ControlNameStr_get(void) {
43843 PyObject *pyobj = 0;
43844
43845 {
43846 #if wxUSE_UNICODE
43847 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43848 #else
43849 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43850 #endif
43851 }
43852 return pyobj;
43853 }
43854
43855
43856 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43857 PyObject *resultobj = 0;
43858 wxWindow *arg1 = (wxWindow *) 0 ;
43859 int arg2 = (int) -1 ;
43860 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43861 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43862 wxSize const &arg4_defvalue = wxDefaultSize ;
43863 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43864 long arg5 = (long) 0 ;
43865 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43866 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43867 wxString const &arg7_defvalue = wxPyControlNameStr ;
43868 wxString *arg7 = (wxString *) &arg7_defvalue ;
43869 wxControl *result = 0 ;
43870 void *argp1 = 0 ;
43871 int res1 = 0 ;
43872 int val2 ;
43873 int ecode2 = 0 ;
43874 wxPoint temp3 ;
43875 wxSize temp4 ;
43876 long val5 ;
43877 int ecode5 = 0 ;
43878 void *argp6 = 0 ;
43879 int res6 = 0 ;
43880 bool temp7 = false ;
43881 PyObject * obj0 = 0 ;
43882 PyObject * obj1 = 0 ;
43883 PyObject * obj2 = 0 ;
43884 PyObject * obj3 = 0 ;
43885 PyObject * obj4 = 0 ;
43886 PyObject * obj5 = 0 ;
43887 PyObject * obj6 = 0 ;
43888 char * kwnames[] = {
43889 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43890 };
43891
43892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43894 if (!SWIG_IsOK(res1)) {
43895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43896 }
43897 arg1 = reinterpret_cast< wxWindow * >(argp1);
43898 if (obj1) {
43899 ecode2 = SWIG_AsVal_int(obj1, &val2);
43900 if (!SWIG_IsOK(ecode2)) {
43901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43902 }
43903 arg2 = static_cast< int >(val2);
43904 }
43905 if (obj2) {
43906 {
43907 arg3 = &temp3;
43908 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43909 }
43910 }
43911 if (obj3) {
43912 {
43913 arg4 = &temp4;
43914 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43915 }
43916 }
43917 if (obj4) {
43918 ecode5 = SWIG_AsVal_long(obj4, &val5);
43919 if (!SWIG_IsOK(ecode5)) {
43920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43921 }
43922 arg5 = static_cast< long >(val5);
43923 }
43924 if (obj5) {
43925 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43926 if (!SWIG_IsOK(res6)) {
43927 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43928 }
43929 if (!argp6) {
43930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43931 }
43932 arg6 = reinterpret_cast< wxValidator * >(argp6);
43933 }
43934 if (obj6) {
43935 {
43936 arg7 = wxString_in_helper(obj6);
43937 if (arg7 == NULL) SWIG_fail;
43938 temp7 = true;
43939 }
43940 }
43941 {
43942 if (!wxPyCheckForApp()) SWIG_fail;
43943 PyThreadState* __tstate = wxPyBeginAllowThreads();
43944 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43945 wxPyEndAllowThreads(__tstate);
43946 if (PyErr_Occurred()) SWIG_fail;
43947 }
43948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43949 {
43950 if (temp7)
43951 delete arg7;
43952 }
43953 return resultobj;
43954 fail:
43955 {
43956 if (temp7)
43957 delete arg7;
43958 }
43959 return NULL;
43960 }
43961
43962
43963 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43964 PyObject *resultobj = 0;
43965 wxControl *result = 0 ;
43966
43967 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43968 {
43969 if (!wxPyCheckForApp()) SWIG_fail;
43970 PyThreadState* __tstate = wxPyBeginAllowThreads();
43971 result = (wxControl *)new wxControl();
43972 wxPyEndAllowThreads(__tstate);
43973 if (PyErr_Occurred()) SWIG_fail;
43974 }
43975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43976 return resultobj;
43977 fail:
43978 return NULL;
43979 }
43980
43981
43982 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43983 PyObject *resultobj = 0;
43984 wxControl *arg1 = (wxControl *) 0 ;
43985 wxWindow *arg2 = (wxWindow *) 0 ;
43986 int arg3 = (int) -1 ;
43987 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43988 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43989 wxSize const &arg5_defvalue = wxDefaultSize ;
43990 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43991 long arg6 = (long) 0 ;
43992 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43993 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43994 wxString const &arg8_defvalue = wxPyControlNameStr ;
43995 wxString *arg8 = (wxString *) &arg8_defvalue ;
43996 bool result;
43997 void *argp1 = 0 ;
43998 int res1 = 0 ;
43999 void *argp2 = 0 ;
44000 int res2 = 0 ;
44001 int val3 ;
44002 int ecode3 = 0 ;
44003 wxPoint temp4 ;
44004 wxSize temp5 ;
44005 long val6 ;
44006 int ecode6 = 0 ;
44007 void *argp7 = 0 ;
44008 int res7 = 0 ;
44009 bool temp8 = false ;
44010 PyObject * obj0 = 0 ;
44011 PyObject * obj1 = 0 ;
44012 PyObject * obj2 = 0 ;
44013 PyObject * obj3 = 0 ;
44014 PyObject * obj4 = 0 ;
44015 PyObject * obj5 = 0 ;
44016 PyObject * obj6 = 0 ;
44017 PyObject * obj7 = 0 ;
44018 char * kwnames[] = {
44019 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44020 };
44021
44022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44024 if (!SWIG_IsOK(res1)) {
44025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44026 }
44027 arg1 = reinterpret_cast< wxControl * >(argp1);
44028 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44029 if (!SWIG_IsOK(res2)) {
44030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44031 }
44032 arg2 = reinterpret_cast< wxWindow * >(argp2);
44033 if (obj2) {
44034 ecode3 = SWIG_AsVal_int(obj2, &val3);
44035 if (!SWIG_IsOK(ecode3)) {
44036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44037 }
44038 arg3 = static_cast< int >(val3);
44039 }
44040 if (obj3) {
44041 {
44042 arg4 = &temp4;
44043 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44044 }
44045 }
44046 if (obj4) {
44047 {
44048 arg5 = &temp5;
44049 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44050 }
44051 }
44052 if (obj5) {
44053 ecode6 = SWIG_AsVal_long(obj5, &val6);
44054 if (!SWIG_IsOK(ecode6)) {
44055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44056 }
44057 arg6 = static_cast< long >(val6);
44058 }
44059 if (obj6) {
44060 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44061 if (!SWIG_IsOK(res7)) {
44062 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44063 }
44064 if (!argp7) {
44065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44066 }
44067 arg7 = reinterpret_cast< wxValidator * >(argp7);
44068 }
44069 if (obj7) {
44070 {
44071 arg8 = wxString_in_helper(obj7);
44072 if (arg8 == NULL) SWIG_fail;
44073 temp8 = true;
44074 }
44075 }
44076 {
44077 PyThreadState* __tstate = wxPyBeginAllowThreads();
44078 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44079 wxPyEndAllowThreads(__tstate);
44080 if (PyErr_Occurred()) SWIG_fail;
44081 }
44082 {
44083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44084 }
44085 {
44086 if (temp8)
44087 delete arg8;
44088 }
44089 return resultobj;
44090 fail:
44091 {
44092 if (temp8)
44093 delete arg8;
44094 }
44095 return NULL;
44096 }
44097
44098
44099 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44100 PyObject *resultobj = 0;
44101 wxControl *arg1 = (wxControl *) 0 ;
44102 int result;
44103 void *argp1 = 0 ;
44104 int res1 = 0 ;
44105 PyObject *swig_obj[1] ;
44106
44107 if (!args) SWIG_fail;
44108 swig_obj[0] = args;
44109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44110 if (!SWIG_IsOK(res1)) {
44111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44112 }
44113 arg1 = reinterpret_cast< wxControl * >(argp1);
44114 {
44115 PyThreadState* __tstate = wxPyBeginAllowThreads();
44116 result = (int)((wxControl const *)arg1)->GetAlignment();
44117 wxPyEndAllowThreads(__tstate);
44118 if (PyErr_Occurred()) SWIG_fail;
44119 }
44120 resultobj = SWIG_From_int(static_cast< int >(result));
44121 return resultobj;
44122 fail:
44123 return NULL;
44124 }
44125
44126
44127 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44128 PyObject *resultobj = 0;
44129 wxControl *arg1 = (wxControl *) 0 ;
44130 wxString result;
44131 void *argp1 = 0 ;
44132 int res1 = 0 ;
44133 PyObject *swig_obj[1] ;
44134
44135 if (!args) SWIG_fail;
44136 swig_obj[0] = args;
44137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44138 if (!SWIG_IsOK(res1)) {
44139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44140 }
44141 arg1 = reinterpret_cast< wxControl * >(argp1);
44142 {
44143 PyThreadState* __tstate = wxPyBeginAllowThreads();
44144 result = ((wxControl const *)arg1)->GetLabelText();
44145 wxPyEndAllowThreads(__tstate);
44146 if (PyErr_Occurred()) SWIG_fail;
44147 }
44148 {
44149 #if wxUSE_UNICODE
44150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44151 #else
44152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44153 #endif
44154 }
44155 return resultobj;
44156 fail:
44157 return NULL;
44158 }
44159
44160
44161 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44162 PyObject *resultobj = 0;
44163 wxControl *arg1 = (wxControl *) 0 ;
44164 wxCommandEvent *arg2 = 0 ;
44165 void *argp1 = 0 ;
44166 int res1 = 0 ;
44167 void *argp2 = 0 ;
44168 int res2 = 0 ;
44169 PyObject * obj0 = 0 ;
44170 PyObject * obj1 = 0 ;
44171 char * kwnames[] = {
44172 (char *) "self",(char *) "event", NULL
44173 };
44174
44175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44177 if (!SWIG_IsOK(res1)) {
44178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44179 }
44180 arg1 = reinterpret_cast< wxControl * >(argp1);
44181 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44182 if (!SWIG_IsOK(res2)) {
44183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44184 }
44185 if (!argp2) {
44186 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44187 }
44188 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44189 {
44190 PyThreadState* __tstate = wxPyBeginAllowThreads();
44191 (arg1)->Command(*arg2);
44192 wxPyEndAllowThreads(__tstate);
44193 if (PyErr_Occurred()) SWIG_fail;
44194 }
44195 resultobj = SWIG_Py_Void();
44196 return resultobj;
44197 fail:
44198 return NULL;
44199 }
44200
44201
44202 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44203 PyObject *resultobj = 0;
44204 wxControl *arg1 = (wxControl *) 0 ;
44205 wxString result;
44206 void *argp1 = 0 ;
44207 int res1 = 0 ;
44208 PyObject *swig_obj[1] ;
44209
44210 if (!args) SWIG_fail;
44211 swig_obj[0] = args;
44212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44213 if (!SWIG_IsOK(res1)) {
44214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44215 }
44216 arg1 = reinterpret_cast< wxControl * >(argp1);
44217 {
44218 PyThreadState* __tstate = wxPyBeginAllowThreads();
44219 result = (arg1)->GetLabel();
44220 wxPyEndAllowThreads(__tstate);
44221 if (PyErr_Occurred()) SWIG_fail;
44222 }
44223 {
44224 #if wxUSE_UNICODE
44225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44226 #else
44227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44228 #endif
44229 }
44230 return resultobj;
44231 fail:
44232 return NULL;
44233 }
44234
44235
44236 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44237 PyObject *resultobj = 0;
44238 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44239 SwigValueWrapper<wxVisualAttributes > result;
44240 int val1 ;
44241 int ecode1 = 0 ;
44242 PyObject * obj0 = 0 ;
44243 char * kwnames[] = {
44244 (char *) "variant", NULL
44245 };
44246
44247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44248 if (obj0) {
44249 ecode1 = SWIG_AsVal_int(obj0, &val1);
44250 if (!SWIG_IsOK(ecode1)) {
44251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44252 }
44253 arg1 = static_cast< wxWindowVariant >(val1);
44254 }
44255 {
44256 if (!wxPyCheckForApp()) SWIG_fail;
44257 PyThreadState* __tstate = wxPyBeginAllowThreads();
44258 result = wxControl::GetClassDefaultAttributes(arg1);
44259 wxPyEndAllowThreads(__tstate);
44260 if (PyErr_Occurred()) SWIG_fail;
44261 }
44262 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44263 return resultobj;
44264 fail:
44265 return NULL;
44266 }
44267
44268
44269 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44270 PyObject *obj;
44271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44272 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44273 return SWIG_Py_Void();
44274 }
44275
44276 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44277 return SWIG_Python_InitShadowInstance(args);
44278 }
44279
44280 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44281 PyObject *resultobj = 0;
44282 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44283 wxString *arg2 = 0 ;
44284 PyObject *arg3 = (PyObject *) NULL ;
44285 int result;
44286 void *argp1 = 0 ;
44287 int res1 = 0 ;
44288 bool temp2 = false ;
44289 PyObject * obj0 = 0 ;
44290 PyObject * obj1 = 0 ;
44291 PyObject * obj2 = 0 ;
44292 char * kwnames[] = {
44293 (char *) "self",(char *) "item",(char *) "clientData", NULL
44294 };
44295
44296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44298 if (!SWIG_IsOK(res1)) {
44299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44300 }
44301 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44302 {
44303 arg2 = wxString_in_helper(obj1);
44304 if (arg2 == NULL) SWIG_fail;
44305 temp2 = true;
44306 }
44307 if (obj2) {
44308 arg3 = obj2;
44309 }
44310 {
44311 PyThreadState* __tstate = wxPyBeginAllowThreads();
44312 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44313 wxPyEndAllowThreads(__tstate);
44314 if (PyErr_Occurred()) SWIG_fail;
44315 }
44316 resultobj = SWIG_From_int(static_cast< int >(result));
44317 {
44318 if (temp2)
44319 delete arg2;
44320 }
44321 return resultobj;
44322 fail:
44323 {
44324 if (temp2)
44325 delete arg2;
44326 }
44327 return NULL;
44328 }
44329
44330
44331 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44332 PyObject *resultobj = 0;
44333 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44334 wxArrayString *arg2 = 0 ;
44335 void *argp1 = 0 ;
44336 int res1 = 0 ;
44337 bool temp2 = false ;
44338 PyObject * obj0 = 0 ;
44339 PyObject * obj1 = 0 ;
44340 char * kwnames[] = {
44341 (char *) "self",(char *) "strings", NULL
44342 };
44343
44344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44346 if (!SWIG_IsOK(res1)) {
44347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44348 }
44349 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44350 {
44351 if (! PySequence_Check(obj1)) {
44352 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44353 SWIG_fail;
44354 }
44355 arg2 = new wxArrayString;
44356 temp2 = true;
44357 int i, len=PySequence_Length(obj1);
44358 for (i=0; i<len; i++) {
44359 PyObject* item = PySequence_GetItem(obj1, i);
44360 wxString* s = wxString_in_helper(item);
44361 if (PyErr_Occurred()) SWIG_fail;
44362 arg2->Add(*s);
44363 delete s;
44364 Py_DECREF(item);
44365 }
44366 }
44367 {
44368 PyThreadState* __tstate = wxPyBeginAllowThreads();
44369 (arg1)->Append((wxArrayString const &)*arg2);
44370 wxPyEndAllowThreads(__tstate);
44371 if (PyErr_Occurred()) SWIG_fail;
44372 }
44373 resultobj = SWIG_Py_Void();
44374 {
44375 if (temp2) delete arg2;
44376 }
44377 return resultobj;
44378 fail:
44379 {
44380 if (temp2) delete arg2;
44381 }
44382 return NULL;
44383 }
44384
44385
44386 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44387 PyObject *resultobj = 0;
44388 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44389 wxString *arg2 = 0 ;
44390 unsigned int arg3 ;
44391 PyObject *arg4 = (PyObject *) NULL ;
44392 int result;
44393 void *argp1 = 0 ;
44394 int res1 = 0 ;
44395 bool temp2 = false ;
44396 unsigned int val3 ;
44397 int ecode3 = 0 ;
44398 PyObject * obj0 = 0 ;
44399 PyObject * obj1 = 0 ;
44400 PyObject * obj2 = 0 ;
44401 PyObject * obj3 = 0 ;
44402 char * kwnames[] = {
44403 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44404 };
44405
44406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44408 if (!SWIG_IsOK(res1)) {
44409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44410 }
44411 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44412 {
44413 arg2 = wxString_in_helper(obj1);
44414 if (arg2 == NULL) SWIG_fail;
44415 temp2 = true;
44416 }
44417 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44418 if (!SWIG_IsOK(ecode3)) {
44419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44420 }
44421 arg3 = static_cast< unsigned int >(val3);
44422 if (obj3) {
44423 arg4 = obj3;
44424 }
44425 {
44426 PyThreadState* __tstate = wxPyBeginAllowThreads();
44427 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44428 wxPyEndAllowThreads(__tstate);
44429 if (PyErr_Occurred()) SWIG_fail;
44430 }
44431 resultobj = SWIG_From_int(static_cast< int >(result));
44432 {
44433 if (temp2)
44434 delete arg2;
44435 }
44436 return resultobj;
44437 fail:
44438 {
44439 if (temp2)
44440 delete arg2;
44441 }
44442 return NULL;
44443 }
44444
44445
44446 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44447 PyObject *resultobj = 0;
44448 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44449 void *argp1 = 0 ;
44450 int res1 = 0 ;
44451 PyObject *swig_obj[1] ;
44452
44453 if (!args) SWIG_fail;
44454 swig_obj[0] = args;
44455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44456 if (!SWIG_IsOK(res1)) {
44457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44458 }
44459 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44460 {
44461 PyThreadState* __tstate = wxPyBeginAllowThreads();
44462 (arg1)->Clear();
44463 wxPyEndAllowThreads(__tstate);
44464 if (PyErr_Occurred()) SWIG_fail;
44465 }
44466 resultobj = SWIG_Py_Void();
44467 return resultobj;
44468 fail:
44469 return NULL;
44470 }
44471
44472
44473 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44474 PyObject *resultobj = 0;
44475 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44476 unsigned int arg2 ;
44477 void *argp1 = 0 ;
44478 int res1 = 0 ;
44479 unsigned int val2 ;
44480 int ecode2 = 0 ;
44481 PyObject * obj0 = 0 ;
44482 PyObject * obj1 = 0 ;
44483 char * kwnames[] = {
44484 (char *) "self",(char *) "n", NULL
44485 };
44486
44487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44489 if (!SWIG_IsOK(res1)) {
44490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44491 }
44492 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44493 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44494 if (!SWIG_IsOK(ecode2)) {
44495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44496 }
44497 arg2 = static_cast< unsigned int >(val2);
44498 {
44499 PyThreadState* __tstate = wxPyBeginAllowThreads();
44500 (arg1)->Delete(arg2);
44501 wxPyEndAllowThreads(__tstate);
44502 if (PyErr_Occurred()) SWIG_fail;
44503 }
44504 resultobj = SWIG_Py_Void();
44505 return resultobj;
44506 fail:
44507 return NULL;
44508 }
44509
44510
44511 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44512 PyObject *resultobj = 0;
44513 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44514 unsigned int arg2 ;
44515 PyObject *result = 0 ;
44516 void *argp1 = 0 ;
44517 int res1 = 0 ;
44518 unsigned int val2 ;
44519 int ecode2 = 0 ;
44520 PyObject * obj0 = 0 ;
44521 PyObject * obj1 = 0 ;
44522 char * kwnames[] = {
44523 (char *) "self",(char *) "n", NULL
44524 };
44525
44526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44528 if (!SWIG_IsOK(res1)) {
44529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44530 }
44531 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44532 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44533 if (!SWIG_IsOK(ecode2)) {
44534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44535 }
44536 arg2 = static_cast< unsigned int >(val2);
44537 {
44538 PyThreadState* __tstate = wxPyBeginAllowThreads();
44539 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44540 wxPyEndAllowThreads(__tstate);
44541 if (PyErr_Occurred()) SWIG_fail;
44542 }
44543 resultobj = result;
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj = 0;
44552 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44553 unsigned int arg2 ;
44554 PyObject *arg3 = (PyObject *) 0 ;
44555 void *argp1 = 0 ;
44556 int res1 = 0 ;
44557 unsigned int val2 ;
44558 int ecode2 = 0 ;
44559 PyObject * obj0 = 0 ;
44560 PyObject * obj1 = 0 ;
44561 PyObject * obj2 = 0 ;
44562 char * kwnames[] = {
44563 (char *) "self",(char *) "n",(char *) "clientData", NULL
44564 };
44565
44566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44568 if (!SWIG_IsOK(res1)) {
44569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44570 }
44571 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44572 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44573 if (!SWIG_IsOK(ecode2)) {
44574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44575 }
44576 arg2 = static_cast< unsigned int >(val2);
44577 arg3 = obj2;
44578 {
44579 PyThreadState* __tstate = wxPyBeginAllowThreads();
44580 wxItemContainer_SetClientData(arg1,arg2,arg3);
44581 wxPyEndAllowThreads(__tstate);
44582 if (PyErr_Occurred()) SWIG_fail;
44583 }
44584 resultobj = SWIG_Py_Void();
44585 return resultobj;
44586 fail:
44587 return NULL;
44588 }
44589
44590
44591 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44592 PyObject *resultobj = 0;
44593 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44594 unsigned int result;
44595 void *argp1 = 0 ;
44596 int res1 = 0 ;
44597 PyObject *swig_obj[1] ;
44598
44599 if (!args) SWIG_fail;
44600 swig_obj[0] = args;
44601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44602 if (!SWIG_IsOK(res1)) {
44603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44604 }
44605 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44606 {
44607 PyThreadState* __tstate = wxPyBeginAllowThreads();
44608 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44609 wxPyEndAllowThreads(__tstate);
44610 if (PyErr_Occurred()) SWIG_fail;
44611 }
44612 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44613 return resultobj;
44614 fail:
44615 return NULL;
44616 }
44617
44618
44619 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44620 PyObject *resultobj = 0;
44621 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44622 bool result;
44623 void *argp1 = 0 ;
44624 int res1 = 0 ;
44625 PyObject *swig_obj[1] ;
44626
44627 if (!args) SWIG_fail;
44628 swig_obj[0] = args;
44629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44630 if (!SWIG_IsOK(res1)) {
44631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44632 }
44633 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44634 {
44635 PyThreadState* __tstate = wxPyBeginAllowThreads();
44636 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44637 wxPyEndAllowThreads(__tstate);
44638 if (PyErr_Occurred()) SWIG_fail;
44639 }
44640 {
44641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44642 }
44643 return resultobj;
44644 fail:
44645 return NULL;
44646 }
44647
44648
44649 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44650 PyObject *resultobj = 0;
44651 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44652 unsigned int arg2 ;
44653 wxString result;
44654 void *argp1 = 0 ;
44655 int res1 = 0 ;
44656 unsigned int val2 ;
44657 int ecode2 = 0 ;
44658 PyObject * obj0 = 0 ;
44659 PyObject * obj1 = 0 ;
44660 char * kwnames[] = {
44661 (char *) "self",(char *) "n", NULL
44662 };
44663
44664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44666 if (!SWIG_IsOK(res1)) {
44667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44668 }
44669 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44670 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44671 if (!SWIG_IsOK(ecode2)) {
44672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44673 }
44674 arg2 = static_cast< unsigned int >(val2);
44675 {
44676 PyThreadState* __tstate = wxPyBeginAllowThreads();
44677 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44678 wxPyEndAllowThreads(__tstate);
44679 if (PyErr_Occurred()) SWIG_fail;
44680 }
44681 {
44682 #if wxUSE_UNICODE
44683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44684 #else
44685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44686 #endif
44687 }
44688 return resultobj;
44689 fail:
44690 return NULL;
44691 }
44692
44693
44694 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44695 PyObject *resultobj = 0;
44696 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44697 wxArrayString result;
44698 void *argp1 = 0 ;
44699 int res1 = 0 ;
44700 PyObject *swig_obj[1] ;
44701
44702 if (!args) SWIG_fail;
44703 swig_obj[0] = args;
44704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44705 if (!SWIG_IsOK(res1)) {
44706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44707 }
44708 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44709 {
44710 PyThreadState* __tstate = wxPyBeginAllowThreads();
44711 result = ((wxItemContainer const *)arg1)->GetStrings();
44712 wxPyEndAllowThreads(__tstate);
44713 if (PyErr_Occurred()) SWIG_fail;
44714 }
44715 {
44716 resultobj = wxArrayString2PyList_helper(result);
44717 }
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44725 PyObject *resultobj = 0;
44726 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44727 unsigned int arg2 ;
44728 wxString *arg3 = 0 ;
44729 void *argp1 = 0 ;
44730 int res1 = 0 ;
44731 unsigned int val2 ;
44732 int ecode2 = 0 ;
44733 bool temp3 = false ;
44734 PyObject * obj0 = 0 ;
44735 PyObject * obj1 = 0 ;
44736 PyObject * obj2 = 0 ;
44737 char * kwnames[] = {
44738 (char *) "self",(char *) "n",(char *) "s", NULL
44739 };
44740
44741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44743 if (!SWIG_IsOK(res1)) {
44744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44745 }
44746 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44747 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44748 if (!SWIG_IsOK(ecode2)) {
44749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44750 }
44751 arg2 = static_cast< unsigned int >(val2);
44752 {
44753 arg3 = wxString_in_helper(obj2);
44754 if (arg3 == NULL) SWIG_fail;
44755 temp3 = true;
44756 }
44757 {
44758 PyThreadState* __tstate = wxPyBeginAllowThreads();
44759 (arg1)->SetString(arg2,(wxString const &)*arg3);
44760 wxPyEndAllowThreads(__tstate);
44761 if (PyErr_Occurred()) SWIG_fail;
44762 }
44763 resultobj = SWIG_Py_Void();
44764 {
44765 if (temp3)
44766 delete arg3;
44767 }
44768 return resultobj;
44769 fail:
44770 {
44771 if (temp3)
44772 delete arg3;
44773 }
44774 return NULL;
44775 }
44776
44777
44778 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44779 PyObject *resultobj = 0;
44780 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44781 wxString *arg2 = 0 ;
44782 int result;
44783 void *argp1 = 0 ;
44784 int res1 = 0 ;
44785 bool temp2 = false ;
44786 PyObject * obj0 = 0 ;
44787 PyObject * obj1 = 0 ;
44788 char * kwnames[] = {
44789 (char *) "self",(char *) "s", NULL
44790 };
44791
44792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44794 if (!SWIG_IsOK(res1)) {
44795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44796 }
44797 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44798 {
44799 arg2 = wxString_in_helper(obj1);
44800 if (arg2 == NULL) SWIG_fail;
44801 temp2 = true;
44802 }
44803 {
44804 PyThreadState* __tstate = wxPyBeginAllowThreads();
44805 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44806 wxPyEndAllowThreads(__tstate);
44807 if (PyErr_Occurred()) SWIG_fail;
44808 }
44809 resultobj = SWIG_From_int(static_cast< int >(result));
44810 {
44811 if (temp2)
44812 delete arg2;
44813 }
44814 return resultobj;
44815 fail:
44816 {
44817 if (temp2)
44818 delete arg2;
44819 }
44820 return NULL;
44821 }
44822
44823
44824 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44825 PyObject *resultobj = 0;
44826 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44827 int arg2 ;
44828 void *argp1 = 0 ;
44829 int res1 = 0 ;
44830 int val2 ;
44831 int ecode2 = 0 ;
44832 PyObject * obj0 = 0 ;
44833 PyObject * obj1 = 0 ;
44834 char * kwnames[] = {
44835 (char *) "self",(char *) "n", NULL
44836 };
44837
44838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44840 if (!SWIG_IsOK(res1)) {
44841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44842 }
44843 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44844 ecode2 = SWIG_AsVal_int(obj1, &val2);
44845 if (!SWIG_IsOK(ecode2)) {
44846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44847 }
44848 arg2 = static_cast< int >(val2);
44849 {
44850 PyThreadState* __tstate = wxPyBeginAllowThreads();
44851 (arg1)->SetSelection(arg2);
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 resultobj = SWIG_Py_Void();
44856 return resultobj;
44857 fail:
44858 return NULL;
44859 }
44860
44861
44862 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44863 PyObject *resultobj = 0;
44864 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44865 int result;
44866 void *argp1 = 0 ;
44867 int res1 = 0 ;
44868 PyObject *swig_obj[1] ;
44869
44870 if (!args) SWIG_fail;
44871 swig_obj[0] = args;
44872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44873 if (!SWIG_IsOK(res1)) {
44874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44875 }
44876 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44877 {
44878 PyThreadState* __tstate = wxPyBeginAllowThreads();
44879 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44880 wxPyEndAllowThreads(__tstate);
44881 if (PyErr_Occurred()) SWIG_fail;
44882 }
44883 resultobj = SWIG_From_int(static_cast< int >(result));
44884 return resultobj;
44885 fail:
44886 return NULL;
44887 }
44888
44889
44890 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44891 PyObject *resultobj = 0;
44892 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44893 wxString *arg2 = 0 ;
44894 bool result;
44895 void *argp1 = 0 ;
44896 int res1 = 0 ;
44897 bool temp2 = false ;
44898 PyObject * obj0 = 0 ;
44899 PyObject * obj1 = 0 ;
44900 char * kwnames[] = {
44901 (char *) "self",(char *) "s", NULL
44902 };
44903
44904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44906 if (!SWIG_IsOK(res1)) {
44907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44908 }
44909 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44910 {
44911 arg2 = wxString_in_helper(obj1);
44912 if (arg2 == NULL) SWIG_fail;
44913 temp2 = true;
44914 }
44915 {
44916 PyThreadState* __tstate = wxPyBeginAllowThreads();
44917 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44918 wxPyEndAllowThreads(__tstate);
44919 if (PyErr_Occurred()) SWIG_fail;
44920 }
44921 {
44922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44923 }
44924 {
44925 if (temp2)
44926 delete arg2;
44927 }
44928 return resultobj;
44929 fail:
44930 {
44931 if (temp2)
44932 delete arg2;
44933 }
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44939 PyObject *resultobj = 0;
44940 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44941 wxString result;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 PyObject *swig_obj[1] ;
44945
44946 if (!args) SWIG_fail;
44947 swig_obj[0] = args;
44948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44949 if (!SWIG_IsOK(res1)) {
44950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44951 }
44952 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44953 {
44954 PyThreadState* __tstate = wxPyBeginAllowThreads();
44955 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44956 wxPyEndAllowThreads(__tstate);
44957 if (PyErr_Occurred()) SWIG_fail;
44958 }
44959 {
44960 #if wxUSE_UNICODE
44961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44962 #else
44963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44964 #endif
44965 }
44966 return resultobj;
44967 fail:
44968 return NULL;
44969 }
44970
44971
44972 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44973 PyObject *resultobj = 0;
44974 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44975 int arg2 ;
44976 void *argp1 = 0 ;
44977 int res1 = 0 ;
44978 int val2 ;
44979 int ecode2 = 0 ;
44980 PyObject * obj0 = 0 ;
44981 PyObject * obj1 = 0 ;
44982 char * kwnames[] = {
44983 (char *) "self",(char *) "n", NULL
44984 };
44985
44986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44988 if (!SWIG_IsOK(res1)) {
44989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44990 }
44991 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44992 ecode2 = SWIG_AsVal_int(obj1, &val2);
44993 if (!SWIG_IsOK(ecode2)) {
44994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44995 }
44996 arg2 = static_cast< int >(val2);
44997 {
44998 PyThreadState* __tstate = wxPyBeginAllowThreads();
44999 (arg1)->Select(arg2);
45000 wxPyEndAllowThreads(__tstate);
45001 if (PyErr_Occurred()) SWIG_fail;
45002 }
45003 resultobj = SWIG_Py_Void();
45004 return resultobj;
45005 fail:
45006 return NULL;
45007 }
45008
45009
45010 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45011 PyObject *obj;
45012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45013 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45014 return SWIG_Py_Void();
45015 }
45016
45017 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45018 PyObject *obj;
45019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45020 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45021 return SWIG_Py_Void();
45022 }
45023
45024 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45025 PyObject *resultobj = 0;
45026 wxSizerItem *result = 0 ;
45027
45028 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45029 {
45030 PyThreadState* __tstate = wxPyBeginAllowThreads();
45031 result = (wxSizerItem *)new wxSizerItem();
45032 wxPyEndAllowThreads(__tstate);
45033 if (PyErr_Occurred()) SWIG_fail;
45034 }
45035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45036 return resultobj;
45037 fail:
45038 return NULL;
45039 }
45040
45041
45042 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45043 PyObject *resultobj = 0;
45044 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45045 void *argp1 = 0 ;
45046 int res1 = 0 ;
45047 PyObject *swig_obj[1] ;
45048
45049 if (!args) SWIG_fail;
45050 swig_obj[0] = args;
45051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45052 if (!SWIG_IsOK(res1)) {
45053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45054 }
45055 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45056 {
45057 PyThreadState* __tstate = wxPyBeginAllowThreads();
45058 delete arg1;
45059
45060 wxPyEndAllowThreads(__tstate);
45061 if (PyErr_Occurred()) SWIG_fail;
45062 }
45063 resultobj = SWIG_Py_Void();
45064 return resultobj;
45065 fail:
45066 return NULL;
45067 }
45068
45069
45070 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45071 PyObject *resultobj = 0;
45072 wxWindow *arg1 = (wxWindow *) 0 ;
45073 int arg2 ;
45074 int arg3 ;
45075 int arg4 ;
45076 PyObject *arg5 = (PyObject *) NULL ;
45077 wxSizerItem *result = 0 ;
45078 void *argp1 = 0 ;
45079 int res1 = 0 ;
45080 int val2 ;
45081 int ecode2 = 0 ;
45082 int val3 ;
45083 int ecode3 = 0 ;
45084 int val4 ;
45085 int ecode4 = 0 ;
45086 PyObject * obj0 = 0 ;
45087 PyObject * obj1 = 0 ;
45088 PyObject * obj2 = 0 ;
45089 PyObject * obj3 = 0 ;
45090 PyObject * obj4 = 0 ;
45091 char * kwnames[] = {
45092 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45093 };
45094
45095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45097 if (!SWIG_IsOK(res1)) {
45098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45099 }
45100 arg1 = reinterpret_cast< wxWindow * >(argp1);
45101 ecode2 = SWIG_AsVal_int(obj1, &val2);
45102 if (!SWIG_IsOK(ecode2)) {
45103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45104 }
45105 arg2 = static_cast< int >(val2);
45106 ecode3 = SWIG_AsVal_int(obj2, &val3);
45107 if (!SWIG_IsOK(ecode3)) {
45108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45109 }
45110 arg3 = static_cast< int >(val3);
45111 ecode4 = SWIG_AsVal_int(obj3, &val4);
45112 if (!SWIG_IsOK(ecode4)) {
45113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45114 }
45115 arg4 = static_cast< int >(val4);
45116 if (obj4) {
45117 arg5 = obj4;
45118 }
45119 {
45120 PyThreadState* __tstate = wxPyBeginAllowThreads();
45121 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45122 wxPyEndAllowThreads(__tstate);
45123 if (PyErr_Occurred()) SWIG_fail;
45124 }
45125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45126 return resultobj;
45127 fail:
45128 return NULL;
45129 }
45130
45131
45132 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45133 PyObject *resultobj = 0;
45134 int arg1 ;
45135 int arg2 ;
45136 int arg3 ;
45137 int arg4 ;
45138 int arg5 ;
45139 PyObject *arg6 = (PyObject *) NULL ;
45140 wxSizerItem *result = 0 ;
45141 int val1 ;
45142 int ecode1 = 0 ;
45143 int val2 ;
45144 int ecode2 = 0 ;
45145 int val3 ;
45146 int ecode3 = 0 ;
45147 int val4 ;
45148 int ecode4 = 0 ;
45149 int val5 ;
45150 int ecode5 = 0 ;
45151 PyObject * obj0 = 0 ;
45152 PyObject * obj1 = 0 ;
45153 PyObject * obj2 = 0 ;
45154 PyObject * obj3 = 0 ;
45155 PyObject * obj4 = 0 ;
45156 PyObject * obj5 = 0 ;
45157 char * kwnames[] = {
45158 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45159 };
45160
45161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45162 ecode1 = SWIG_AsVal_int(obj0, &val1);
45163 if (!SWIG_IsOK(ecode1)) {
45164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45165 }
45166 arg1 = static_cast< int >(val1);
45167 ecode2 = SWIG_AsVal_int(obj1, &val2);
45168 if (!SWIG_IsOK(ecode2)) {
45169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45170 }
45171 arg2 = static_cast< int >(val2);
45172 ecode3 = SWIG_AsVal_int(obj2, &val3);
45173 if (!SWIG_IsOK(ecode3)) {
45174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45175 }
45176 arg3 = static_cast< int >(val3);
45177 ecode4 = SWIG_AsVal_int(obj3, &val4);
45178 if (!SWIG_IsOK(ecode4)) {
45179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45180 }
45181 arg4 = static_cast< int >(val4);
45182 ecode5 = SWIG_AsVal_int(obj4, &val5);
45183 if (!SWIG_IsOK(ecode5)) {
45184 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45185 }
45186 arg5 = static_cast< int >(val5);
45187 if (obj5) {
45188 arg6 = obj5;
45189 }
45190 {
45191 PyThreadState* __tstate = wxPyBeginAllowThreads();
45192 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45193 wxPyEndAllowThreads(__tstate);
45194 if (PyErr_Occurred()) SWIG_fail;
45195 }
45196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45197 return resultobj;
45198 fail:
45199 return NULL;
45200 }
45201
45202
45203 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45204 PyObject *resultobj = 0;
45205 wxSizer *arg1 = (wxSizer *) 0 ;
45206 int arg2 ;
45207 int arg3 ;
45208 int arg4 ;
45209 PyObject *arg5 = (PyObject *) NULL ;
45210 wxSizerItem *result = 0 ;
45211 int res1 = 0 ;
45212 int val2 ;
45213 int ecode2 = 0 ;
45214 int val3 ;
45215 int ecode3 = 0 ;
45216 int val4 ;
45217 int ecode4 = 0 ;
45218 PyObject * obj0 = 0 ;
45219 PyObject * obj1 = 0 ;
45220 PyObject * obj2 = 0 ;
45221 PyObject * obj3 = 0 ;
45222 PyObject * obj4 = 0 ;
45223 char * kwnames[] = {
45224 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45225 };
45226
45227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45228 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45229 if (!SWIG_IsOK(res1)) {
45230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45231 }
45232 ecode2 = SWIG_AsVal_int(obj1, &val2);
45233 if (!SWIG_IsOK(ecode2)) {
45234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45235 }
45236 arg2 = static_cast< int >(val2);
45237 ecode3 = SWIG_AsVal_int(obj2, &val3);
45238 if (!SWIG_IsOK(ecode3)) {
45239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45240 }
45241 arg3 = static_cast< int >(val3);
45242 ecode4 = SWIG_AsVal_int(obj3, &val4);
45243 if (!SWIG_IsOK(ecode4)) {
45244 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45245 }
45246 arg4 = static_cast< int >(val4);
45247 if (obj4) {
45248 arg5 = obj4;
45249 }
45250 {
45251 PyThreadState* __tstate = wxPyBeginAllowThreads();
45252 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45253 wxPyEndAllowThreads(__tstate);
45254 if (PyErr_Occurred()) SWIG_fail;
45255 }
45256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45257 return resultobj;
45258 fail:
45259 return NULL;
45260 }
45261
45262
45263 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45264 PyObject *resultobj = 0;
45265 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45266 void *argp1 = 0 ;
45267 int res1 = 0 ;
45268 PyObject *swig_obj[1] ;
45269
45270 if (!args) SWIG_fail;
45271 swig_obj[0] = args;
45272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45273 if (!SWIG_IsOK(res1)) {
45274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45275 }
45276 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45277 {
45278 PyThreadState* __tstate = wxPyBeginAllowThreads();
45279 (arg1)->DeleteWindows();
45280 wxPyEndAllowThreads(__tstate);
45281 if (PyErr_Occurred()) SWIG_fail;
45282 }
45283 resultobj = SWIG_Py_Void();
45284 return resultobj;
45285 fail:
45286 return NULL;
45287 }
45288
45289
45290 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45291 PyObject *resultobj = 0;
45292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45293 void *argp1 = 0 ;
45294 int res1 = 0 ;
45295 PyObject *swig_obj[1] ;
45296
45297 if (!args) SWIG_fail;
45298 swig_obj[0] = args;
45299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45300 if (!SWIG_IsOK(res1)) {
45301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45302 }
45303 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45304 {
45305 PyThreadState* __tstate = wxPyBeginAllowThreads();
45306 (arg1)->DetachSizer();
45307 wxPyEndAllowThreads(__tstate);
45308 if (PyErr_Occurred()) SWIG_fail;
45309 }
45310 resultobj = SWIG_Py_Void();
45311 return resultobj;
45312 fail:
45313 return NULL;
45314 }
45315
45316
45317 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45318 PyObject *resultobj = 0;
45319 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45320 wxSize result;
45321 void *argp1 = 0 ;
45322 int res1 = 0 ;
45323 PyObject *swig_obj[1] ;
45324
45325 if (!args) SWIG_fail;
45326 swig_obj[0] = args;
45327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45328 if (!SWIG_IsOK(res1)) {
45329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45330 }
45331 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45332 {
45333 PyThreadState* __tstate = wxPyBeginAllowThreads();
45334 result = (arg1)->GetSize();
45335 wxPyEndAllowThreads(__tstate);
45336 if (PyErr_Occurred()) SWIG_fail;
45337 }
45338 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45339 return resultobj;
45340 fail:
45341 return NULL;
45342 }
45343
45344
45345 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45346 PyObject *resultobj = 0;
45347 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45348 wxSize result;
45349 void *argp1 = 0 ;
45350 int res1 = 0 ;
45351 PyObject *swig_obj[1] ;
45352
45353 if (!args) SWIG_fail;
45354 swig_obj[0] = args;
45355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45356 if (!SWIG_IsOK(res1)) {
45357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45358 }
45359 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45360 {
45361 PyThreadState* __tstate = wxPyBeginAllowThreads();
45362 result = (arg1)->CalcMin();
45363 wxPyEndAllowThreads(__tstate);
45364 if (PyErr_Occurred()) SWIG_fail;
45365 }
45366 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45367 return resultobj;
45368 fail:
45369 return NULL;
45370 }
45371
45372
45373 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45374 PyObject *resultobj = 0;
45375 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45376 wxPoint *arg2 = 0 ;
45377 wxSize *arg3 = 0 ;
45378 void *argp1 = 0 ;
45379 int res1 = 0 ;
45380 wxPoint temp2 ;
45381 wxSize temp3 ;
45382 PyObject * obj0 = 0 ;
45383 PyObject * obj1 = 0 ;
45384 PyObject * obj2 = 0 ;
45385 char * kwnames[] = {
45386 (char *) "self",(char *) "pos",(char *) "size", NULL
45387 };
45388
45389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45391 if (!SWIG_IsOK(res1)) {
45392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45393 }
45394 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45395 {
45396 arg2 = &temp2;
45397 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45398 }
45399 {
45400 arg3 = &temp3;
45401 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45402 }
45403 {
45404 PyThreadState* __tstate = wxPyBeginAllowThreads();
45405 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45406 wxPyEndAllowThreads(__tstate);
45407 if (PyErr_Occurred()) SWIG_fail;
45408 }
45409 resultobj = SWIG_Py_Void();
45410 return resultobj;
45411 fail:
45412 return NULL;
45413 }
45414
45415
45416 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45417 PyObject *resultobj = 0;
45418 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45419 wxSize result;
45420 void *argp1 = 0 ;
45421 int res1 = 0 ;
45422 PyObject *swig_obj[1] ;
45423
45424 if (!args) SWIG_fail;
45425 swig_obj[0] = args;
45426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45427 if (!SWIG_IsOK(res1)) {
45428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45429 }
45430 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45431 {
45432 PyThreadState* __tstate = wxPyBeginAllowThreads();
45433 result = (arg1)->GetMinSize();
45434 wxPyEndAllowThreads(__tstate);
45435 if (PyErr_Occurred()) SWIG_fail;
45436 }
45437 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45438 return resultobj;
45439 fail:
45440 return NULL;
45441 }
45442
45443
45444 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45445 PyObject *resultobj = 0;
45446 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45447 wxSize result;
45448 void *argp1 = 0 ;
45449 int res1 = 0 ;
45450 PyObject *swig_obj[1] ;
45451
45452 if (!args) SWIG_fail;
45453 swig_obj[0] = args;
45454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45455 if (!SWIG_IsOK(res1)) {
45456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45457 }
45458 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45459 {
45460 PyThreadState* __tstate = wxPyBeginAllowThreads();
45461 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45462 wxPyEndAllowThreads(__tstate);
45463 if (PyErr_Occurred()) SWIG_fail;
45464 }
45465 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45466 return resultobj;
45467 fail:
45468 return NULL;
45469 }
45470
45471
45472 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45473 PyObject *resultobj = 0;
45474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45475 int arg2 ;
45476 int arg3 ;
45477 void *argp1 = 0 ;
45478 int res1 = 0 ;
45479 int val2 ;
45480 int ecode2 = 0 ;
45481 int val3 ;
45482 int ecode3 = 0 ;
45483 PyObject * obj0 = 0 ;
45484 PyObject * obj1 = 0 ;
45485 PyObject * obj2 = 0 ;
45486 char * kwnames[] = {
45487 (char *) "self",(char *) "x",(char *) "y", NULL
45488 };
45489
45490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45492 if (!SWIG_IsOK(res1)) {
45493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45494 }
45495 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45496 ecode2 = SWIG_AsVal_int(obj1, &val2);
45497 if (!SWIG_IsOK(ecode2)) {
45498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45499 }
45500 arg2 = static_cast< int >(val2);
45501 ecode3 = SWIG_AsVal_int(obj2, &val3);
45502 if (!SWIG_IsOK(ecode3)) {
45503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45504 }
45505 arg3 = static_cast< int >(val3);
45506 {
45507 PyThreadState* __tstate = wxPyBeginAllowThreads();
45508 (arg1)->SetInitSize(arg2,arg3);
45509 wxPyEndAllowThreads(__tstate);
45510 if (PyErr_Occurred()) SWIG_fail;
45511 }
45512 resultobj = SWIG_Py_Void();
45513 return resultobj;
45514 fail:
45515 return NULL;
45516 }
45517
45518
45519 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45520 PyObject *resultobj = 0;
45521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45522 int arg2 ;
45523 int arg3 ;
45524 void *argp1 = 0 ;
45525 int res1 = 0 ;
45526 int val2 ;
45527 int ecode2 = 0 ;
45528 int val3 ;
45529 int ecode3 = 0 ;
45530 PyObject * obj0 = 0 ;
45531 PyObject * obj1 = 0 ;
45532 PyObject * obj2 = 0 ;
45533 char * kwnames[] = {
45534 (char *) "self",(char *) "width",(char *) "height", NULL
45535 };
45536
45537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45539 if (!SWIG_IsOK(res1)) {
45540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45541 }
45542 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45543 ecode2 = SWIG_AsVal_int(obj1, &val2);
45544 if (!SWIG_IsOK(ecode2)) {
45545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45546 }
45547 arg2 = static_cast< int >(val2);
45548 ecode3 = SWIG_AsVal_int(obj2, &val3);
45549 if (!SWIG_IsOK(ecode3)) {
45550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45551 }
45552 arg3 = static_cast< int >(val3);
45553 {
45554 PyThreadState* __tstate = wxPyBeginAllowThreads();
45555 (arg1)->SetRatio(arg2,arg3);
45556 wxPyEndAllowThreads(__tstate);
45557 if (PyErr_Occurred()) SWIG_fail;
45558 }
45559 resultobj = SWIG_Py_Void();
45560 return resultobj;
45561 fail:
45562 return NULL;
45563 }
45564
45565
45566 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45567 PyObject *resultobj = 0;
45568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45569 wxSize *arg2 = 0 ;
45570 void *argp1 = 0 ;
45571 int res1 = 0 ;
45572 wxSize temp2 ;
45573 PyObject * obj0 = 0 ;
45574 PyObject * obj1 = 0 ;
45575 char * kwnames[] = {
45576 (char *) "self",(char *) "size", NULL
45577 };
45578
45579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45581 if (!SWIG_IsOK(res1)) {
45582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45583 }
45584 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45585 {
45586 arg2 = &temp2;
45587 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45588 }
45589 {
45590 PyThreadState* __tstate = wxPyBeginAllowThreads();
45591 (arg1)->SetRatio((wxSize const &)*arg2);
45592 wxPyEndAllowThreads(__tstate);
45593 if (PyErr_Occurred()) SWIG_fail;
45594 }
45595 resultobj = SWIG_Py_Void();
45596 return resultobj;
45597 fail:
45598 return NULL;
45599 }
45600
45601
45602 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45603 PyObject *resultobj = 0;
45604 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45605 float arg2 ;
45606 void *argp1 = 0 ;
45607 int res1 = 0 ;
45608 float val2 ;
45609 int ecode2 = 0 ;
45610 PyObject * obj0 = 0 ;
45611 PyObject * obj1 = 0 ;
45612 char * kwnames[] = {
45613 (char *) "self",(char *) "ratio", NULL
45614 };
45615
45616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45618 if (!SWIG_IsOK(res1)) {
45619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45620 }
45621 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45622 ecode2 = SWIG_AsVal_float(obj1, &val2);
45623 if (!SWIG_IsOK(ecode2)) {
45624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45625 }
45626 arg2 = static_cast< float >(val2);
45627 {
45628 PyThreadState* __tstate = wxPyBeginAllowThreads();
45629 (arg1)->SetRatio(arg2);
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_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45641 PyObject *resultobj = 0;
45642 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45643 float 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_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45653 }
45654 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45655 {
45656 PyThreadState* __tstate = wxPyBeginAllowThreads();
45657 result = (float)(arg1)->GetRatio();
45658 wxPyEndAllowThreads(__tstate);
45659 if (PyErr_Occurred()) SWIG_fail;
45660 }
45661 resultobj = SWIG_From_float(static_cast< float >(result));
45662 return resultobj;
45663 fail:
45664 return NULL;
45665 }
45666
45667
45668 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45669 PyObject *resultobj = 0;
45670 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45671 wxRect 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_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45681 }
45682 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45683 {
45684 PyThreadState* __tstate = wxPyBeginAllowThreads();
45685 result = (arg1)->GetRect();
45686 wxPyEndAllowThreads(__tstate);
45687 if (PyErr_Occurred()) SWIG_fail;
45688 }
45689 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45690 return resultobj;
45691 fail:
45692 return NULL;
45693 }
45694
45695
45696 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45697 PyObject *resultobj = 0;
45698 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45699 bool result;
45700 void *argp1 = 0 ;
45701 int res1 = 0 ;
45702 PyObject *swig_obj[1] ;
45703
45704 if (!args) SWIG_fail;
45705 swig_obj[0] = args;
45706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45707 if (!SWIG_IsOK(res1)) {
45708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45709 }
45710 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45711 {
45712 PyThreadState* __tstate = wxPyBeginAllowThreads();
45713 result = (bool)(arg1)->IsWindow();
45714 wxPyEndAllowThreads(__tstate);
45715 if (PyErr_Occurred()) SWIG_fail;
45716 }
45717 {
45718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45719 }
45720 return resultobj;
45721 fail:
45722 return NULL;
45723 }
45724
45725
45726 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45727 PyObject *resultobj = 0;
45728 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45729 bool result;
45730 void *argp1 = 0 ;
45731 int res1 = 0 ;
45732 PyObject *swig_obj[1] ;
45733
45734 if (!args) SWIG_fail;
45735 swig_obj[0] = args;
45736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45737 if (!SWIG_IsOK(res1)) {
45738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45739 }
45740 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45741 {
45742 PyThreadState* __tstate = wxPyBeginAllowThreads();
45743 result = (bool)(arg1)->IsSizer();
45744 wxPyEndAllowThreads(__tstate);
45745 if (PyErr_Occurred()) SWIG_fail;
45746 }
45747 {
45748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45749 }
45750 return resultobj;
45751 fail:
45752 return NULL;
45753 }
45754
45755
45756 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45757 PyObject *resultobj = 0;
45758 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45759 bool result;
45760 void *argp1 = 0 ;
45761 int res1 = 0 ;
45762 PyObject *swig_obj[1] ;
45763
45764 if (!args) SWIG_fail;
45765 swig_obj[0] = args;
45766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45767 if (!SWIG_IsOK(res1)) {
45768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45769 }
45770 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45771 {
45772 PyThreadState* __tstate = wxPyBeginAllowThreads();
45773 result = (bool)(arg1)->IsSpacer();
45774 wxPyEndAllowThreads(__tstate);
45775 if (PyErr_Occurred()) SWIG_fail;
45776 }
45777 {
45778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45779 }
45780 return resultobj;
45781 fail:
45782 return NULL;
45783 }
45784
45785
45786 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45787 PyObject *resultobj = 0;
45788 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45789 int arg2 ;
45790 void *argp1 = 0 ;
45791 int res1 = 0 ;
45792 int val2 ;
45793 int ecode2 = 0 ;
45794 PyObject * obj0 = 0 ;
45795 PyObject * obj1 = 0 ;
45796 char * kwnames[] = {
45797 (char *) "self",(char *) "proportion", NULL
45798 };
45799
45800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45802 if (!SWIG_IsOK(res1)) {
45803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45804 }
45805 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45806 ecode2 = SWIG_AsVal_int(obj1, &val2);
45807 if (!SWIG_IsOK(ecode2)) {
45808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45809 }
45810 arg2 = static_cast< int >(val2);
45811 {
45812 PyThreadState* __tstate = wxPyBeginAllowThreads();
45813 (arg1)->SetProportion(arg2);
45814 wxPyEndAllowThreads(__tstate);
45815 if (PyErr_Occurred()) SWIG_fail;
45816 }
45817 resultobj = SWIG_Py_Void();
45818 return resultobj;
45819 fail:
45820 return NULL;
45821 }
45822
45823
45824 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45825 PyObject *resultobj = 0;
45826 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45827 int result;
45828 void *argp1 = 0 ;
45829 int res1 = 0 ;
45830 PyObject *swig_obj[1] ;
45831
45832 if (!args) SWIG_fail;
45833 swig_obj[0] = args;
45834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45835 if (!SWIG_IsOK(res1)) {
45836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45837 }
45838 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45839 {
45840 PyThreadState* __tstate = wxPyBeginAllowThreads();
45841 result = (int)(arg1)->GetProportion();
45842 wxPyEndAllowThreads(__tstate);
45843 if (PyErr_Occurred()) SWIG_fail;
45844 }
45845 resultobj = SWIG_From_int(static_cast< int >(result));
45846 return resultobj;
45847 fail:
45848 return NULL;
45849 }
45850
45851
45852 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45853 PyObject *resultobj = 0;
45854 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45855 int arg2 ;
45856 void *argp1 = 0 ;
45857 int res1 = 0 ;
45858 int val2 ;
45859 int ecode2 = 0 ;
45860 PyObject * obj0 = 0 ;
45861 PyObject * obj1 = 0 ;
45862 char * kwnames[] = {
45863 (char *) "self",(char *) "flag", NULL
45864 };
45865
45866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45868 if (!SWIG_IsOK(res1)) {
45869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45870 }
45871 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45872 ecode2 = SWIG_AsVal_int(obj1, &val2);
45873 if (!SWIG_IsOK(ecode2)) {
45874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45875 }
45876 arg2 = static_cast< int >(val2);
45877 {
45878 PyThreadState* __tstate = wxPyBeginAllowThreads();
45879 (arg1)->SetFlag(arg2);
45880 wxPyEndAllowThreads(__tstate);
45881 if (PyErr_Occurred()) SWIG_fail;
45882 }
45883 resultobj = SWIG_Py_Void();
45884 return resultobj;
45885 fail:
45886 return NULL;
45887 }
45888
45889
45890 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45891 PyObject *resultobj = 0;
45892 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45893 int result;
45894 void *argp1 = 0 ;
45895 int res1 = 0 ;
45896 PyObject *swig_obj[1] ;
45897
45898 if (!args) SWIG_fail;
45899 swig_obj[0] = args;
45900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45901 if (!SWIG_IsOK(res1)) {
45902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45903 }
45904 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45905 {
45906 PyThreadState* __tstate = wxPyBeginAllowThreads();
45907 result = (int)(arg1)->GetFlag();
45908 wxPyEndAllowThreads(__tstate);
45909 if (PyErr_Occurred()) SWIG_fail;
45910 }
45911 resultobj = SWIG_From_int(static_cast< int >(result));
45912 return resultobj;
45913 fail:
45914 return NULL;
45915 }
45916
45917
45918 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45919 PyObject *resultobj = 0;
45920 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45921 int arg2 ;
45922 void *argp1 = 0 ;
45923 int res1 = 0 ;
45924 int val2 ;
45925 int ecode2 = 0 ;
45926 PyObject * obj0 = 0 ;
45927 PyObject * obj1 = 0 ;
45928 char * kwnames[] = {
45929 (char *) "self",(char *) "border", NULL
45930 };
45931
45932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45934 if (!SWIG_IsOK(res1)) {
45935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45936 }
45937 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45938 ecode2 = SWIG_AsVal_int(obj1, &val2);
45939 if (!SWIG_IsOK(ecode2)) {
45940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45941 }
45942 arg2 = static_cast< int >(val2);
45943 {
45944 PyThreadState* __tstate = wxPyBeginAllowThreads();
45945 (arg1)->SetBorder(arg2);
45946 wxPyEndAllowThreads(__tstate);
45947 if (PyErr_Occurred()) SWIG_fail;
45948 }
45949 resultobj = SWIG_Py_Void();
45950 return resultobj;
45951 fail:
45952 return NULL;
45953 }
45954
45955
45956 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45957 PyObject *resultobj = 0;
45958 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45959 int result;
45960 void *argp1 = 0 ;
45961 int res1 = 0 ;
45962 PyObject *swig_obj[1] ;
45963
45964 if (!args) SWIG_fail;
45965 swig_obj[0] = args;
45966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45967 if (!SWIG_IsOK(res1)) {
45968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45969 }
45970 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 result = (int)(arg1)->GetBorder();
45974 wxPyEndAllowThreads(__tstate);
45975 if (PyErr_Occurred()) SWIG_fail;
45976 }
45977 resultobj = SWIG_From_int(static_cast< int >(result));
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45985 PyObject *resultobj = 0;
45986 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45987 wxWindow *result = 0 ;
45988 void *argp1 = 0 ;
45989 int res1 = 0 ;
45990 PyObject *swig_obj[1] ;
45991
45992 if (!args) SWIG_fail;
45993 swig_obj[0] = args;
45994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45995 if (!SWIG_IsOK(res1)) {
45996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45997 }
45998 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45999 {
46000 PyThreadState* __tstate = wxPyBeginAllowThreads();
46001 result = (wxWindow *)(arg1)->GetWindow();
46002 wxPyEndAllowThreads(__tstate);
46003 if (PyErr_Occurred()) SWIG_fail;
46004 }
46005 {
46006 resultobj = wxPyMake_wxObject(result, 0);
46007 }
46008 return resultobj;
46009 fail:
46010 return NULL;
46011 }
46012
46013
46014 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46015 PyObject *resultobj = 0;
46016 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46017 wxWindow *arg2 = (wxWindow *) 0 ;
46018 void *argp1 = 0 ;
46019 int res1 = 0 ;
46020 void *argp2 = 0 ;
46021 int res2 = 0 ;
46022 PyObject * obj0 = 0 ;
46023 PyObject * obj1 = 0 ;
46024 char * kwnames[] = {
46025 (char *) "self",(char *) "window", NULL
46026 };
46027
46028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46030 if (!SWIG_IsOK(res1)) {
46031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46032 }
46033 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46035 if (!SWIG_IsOK(res2)) {
46036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46037 }
46038 arg2 = reinterpret_cast< wxWindow * >(argp2);
46039 {
46040 PyThreadState* __tstate = wxPyBeginAllowThreads();
46041 (arg1)->SetWindow(arg2);
46042 wxPyEndAllowThreads(__tstate);
46043 if (PyErr_Occurred()) SWIG_fail;
46044 }
46045 resultobj = SWIG_Py_Void();
46046 return resultobj;
46047 fail:
46048 return NULL;
46049 }
46050
46051
46052 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46053 PyObject *resultobj = 0;
46054 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46055 wxSizer *result = 0 ;
46056 void *argp1 = 0 ;
46057 int res1 = 0 ;
46058 PyObject *swig_obj[1] ;
46059
46060 if (!args) SWIG_fail;
46061 swig_obj[0] = args;
46062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46063 if (!SWIG_IsOK(res1)) {
46064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46065 }
46066 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46067 {
46068 PyThreadState* __tstate = wxPyBeginAllowThreads();
46069 result = (wxSizer *)(arg1)->GetSizer();
46070 wxPyEndAllowThreads(__tstate);
46071 if (PyErr_Occurred()) SWIG_fail;
46072 }
46073 {
46074 resultobj = wxPyMake_wxObject(result, (bool)0);
46075 }
46076 return resultobj;
46077 fail:
46078 return NULL;
46079 }
46080
46081
46082 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46083 PyObject *resultobj = 0;
46084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46085 wxSizer *arg2 = (wxSizer *) 0 ;
46086 void *argp1 = 0 ;
46087 int res1 = 0 ;
46088 int res2 = 0 ;
46089 PyObject * obj0 = 0 ;
46090 PyObject * obj1 = 0 ;
46091 char * kwnames[] = {
46092 (char *) "self",(char *) "sizer", NULL
46093 };
46094
46095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46097 if (!SWIG_IsOK(res1)) {
46098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46099 }
46100 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46101 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46102 if (!SWIG_IsOK(res2)) {
46103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46104 }
46105 {
46106 PyThreadState* __tstate = wxPyBeginAllowThreads();
46107 (arg1)->SetSizer(arg2);
46108 wxPyEndAllowThreads(__tstate);
46109 if (PyErr_Occurred()) SWIG_fail;
46110 }
46111 resultobj = SWIG_Py_Void();
46112 return resultobj;
46113 fail:
46114 return NULL;
46115 }
46116
46117
46118 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46119 PyObject *resultobj = 0;
46120 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46121 wxSize *result = 0 ;
46122 void *argp1 = 0 ;
46123 int res1 = 0 ;
46124 PyObject *swig_obj[1] ;
46125
46126 if (!args) SWIG_fail;
46127 swig_obj[0] = args;
46128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46129 if (!SWIG_IsOK(res1)) {
46130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46131 }
46132 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46133 {
46134 PyThreadState* __tstate = wxPyBeginAllowThreads();
46135 {
46136 wxSize const &_result_ref = (arg1)->GetSpacer();
46137 result = (wxSize *) &_result_ref;
46138 }
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46143 return resultobj;
46144 fail:
46145 return NULL;
46146 }
46147
46148
46149 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46150 PyObject *resultobj = 0;
46151 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46152 wxSize *arg2 = 0 ;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 wxSize temp2 ;
46156 PyObject * obj0 = 0 ;
46157 PyObject * obj1 = 0 ;
46158 char * kwnames[] = {
46159 (char *) "self",(char *) "size", NULL
46160 };
46161
46162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46164 if (!SWIG_IsOK(res1)) {
46165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46166 }
46167 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46168 {
46169 arg2 = &temp2;
46170 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46171 }
46172 {
46173 PyThreadState* __tstate = wxPyBeginAllowThreads();
46174 (arg1)->SetSpacer((wxSize const &)*arg2);
46175 wxPyEndAllowThreads(__tstate);
46176 if (PyErr_Occurred()) SWIG_fail;
46177 }
46178 resultobj = SWIG_Py_Void();
46179 return resultobj;
46180 fail:
46181 return NULL;
46182 }
46183
46184
46185 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46186 PyObject *resultobj = 0;
46187 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46188 bool arg2 ;
46189 void *argp1 = 0 ;
46190 int res1 = 0 ;
46191 bool val2 ;
46192 int ecode2 = 0 ;
46193 PyObject * obj0 = 0 ;
46194 PyObject * obj1 = 0 ;
46195 char * kwnames[] = {
46196 (char *) "self",(char *) "show", NULL
46197 };
46198
46199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46201 if (!SWIG_IsOK(res1)) {
46202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46203 }
46204 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46205 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46206 if (!SWIG_IsOK(ecode2)) {
46207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46208 }
46209 arg2 = static_cast< bool >(val2);
46210 {
46211 PyThreadState* __tstate = wxPyBeginAllowThreads();
46212 (arg1)->Show(arg2);
46213 wxPyEndAllowThreads(__tstate);
46214 if (PyErr_Occurred()) SWIG_fail;
46215 }
46216 resultobj = SWIG_Py_Void();
46217 return resultobj;
46218 fail:
46219 return NULL;
46220 }
46221
46222
46223 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46224 PyObject *resultobj = 0;
46225 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46226 bool result;
46227 void *argp1 = 0 ;
46228 int res1 = 0 ;
46229 PyObject *swig_obj[1] ;
46230
46231 if (!args) SWIG_fail;
46232 swig_obj[0] = args;
46233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46234 if (!SWIG_IsOK(res1)) {
46235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46236 }
46237 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46238 {
46239 PyThreadState* __tstate = wxPyBeginAllowThreads();
46240 result = (bool)(arg1)->IsShown();
46241 wxPyEndAllowThreads(__tstate);
46242 if (PyErr_Occurred()) SWIG_fail;
46243 }
46244 {
46245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46246 }
46247 return resultobj;
46248 fail:
46249 return NULL;
46250 }
46251
46252
46253 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46254 PyObject *resultobj = 0;
46255 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46256 wxPoint result;
46257 void *argp1 = 0 ;
46258 int res1 = 0 ;
46259 PyObject *swig_obj[1] ;
46260
46261 if (!args) SWIG_fail;
46262 swig_obj[0] = args;
46263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46264 if (!SWIG_IsOK(res1)) {
46265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46266 }
46267 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46268 {
46269 PyThreadState* __tstate = wxPyBeginAllowThreads();
46270 result = (arg1)->GetPosition();
46271 wxPyEndAllowThreads(__tstate);
46272 if (PyErr_Occurred()) SWIG_fail;
46273 }
46274 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46275 return resultobj;
46276 fail:
46277 return NULL;
46278 }
46279
46280
46281 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46282 PyObject *resultobj = 0;
46283 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46284 PyObject *result = 0 ;
46285 void *argp1 = 0 ;
46286 int res1 = 0 ;
46287 PyObject *swig_obj[1] ;
46288
46289 if (!args) SWIG_fail;
46290 swig_obj[0] = args;
46291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46292 if (!SWIG_IsOK(res1)) {
46293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46294 }
46295 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46296 {
46297 PyThreadState* __tstate = wxPyBeginAllowThreads();
46298 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46299 wxPyEndAllowThreads(__tstate);
46300 if (PyErr_Occurred()) SWIG_fail;
46301 }
46302 resultobj = result;
46303 return resultobj;
46304 fail:
46305 return NULL;
46306 }
46307
46308
46309 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46310 PyObject *resultobj = 0;
46311 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46312 PyObject *arg2 = (PyObject *) 0 ;
46313 void *argp1 = 0 ;
46314 int res1 = 0 ;
46315 PyObject * obj0 = 0 ;
46316 PyObject * obj1 = 0 ;
46317 char * kwnames[] = {
46318 (char *) "self",(char *) "userData", NULL
46319 };
46320
46321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46323 if (!SWIG_IsOK(res1)) {
46324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46325 }
46326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46327 arg2 = obj1;
46328 {
46329 PyThreadState* __tstate = wxPyBeginAllowThreads();
46330 wxSizerItem_SetUserData(arg1,arg2);
46331 wxPyEndAllowThreads(__tstate);
46332 if (PyErr_Occurred()) SWIG_fail;
46333 }
46334 resultobj = SWIG_Py_Void();
46335 return resultobj;
46336 fail:
46337 return NULL;
46338 }
46339
46340
46341 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46342 PyObject *obj;
46343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46344 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46345 return SWIG_Py_Void();
46346 }
46347
46348 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46349 return SWIG_Python_InitShadowInstance(args);
46350 }
46351
46352 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46353 PyObject *resultobj = 0;
46354 wxSizer *arg1 = (wxSizer *) 0 ;
46355 void *argp1 = 0 ;
46356 int res1 = 0 ;
46357 PyObject *swig_obj[1] ;
46358
46359 if (!args) SWIG_fail;
46360 swig_obj[0] = args;
46361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46362 if (!SWIG_IsOK(res1)) {
46363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46364 }
46365 arg1 = reinterpret_cast< wxSizer * >(argp1);
46366 {
46367 PyThreadState* __tstate = wxPyBeginAllowThreads();
46368 delete arg1;
46369
46370 wxPyEndAllowThreads(__tstate);
46371 if (PyErr_Occurred()) SWIG_fail;
46372 }
46373 resultobj = SWIG_Py_Void();
46374 return resultobj;
46375 fail:
46376 return NULL;
46377 }
46378
46379
46380 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46381 PyObject *resultobj = 0;
46382 wxSizer *arg1 = (wxSizer *) 0 ;
46383 PyObject *arg2 = (PyObject *) 0 ;
46384 void *argp1 = 0 ;
46385 int res1 = 0 ;
46386 PyObject * obj0 = 0 ;
46387 PyObject * obj1 = 0 ;
46388 char * kwnames[] = {
46389 (char *) "self",(char *) "_self", NULL
46390 };
46391
46392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46394 if (!SWIG_IsOK(res1)) {
46395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46396 }
46397 arg1 = reinterpret_cast< wxSizer * >(argp1);
46398 arg2 = obj1;
46399 {
46400 PyThreadState* __tstate = wxPyBeginAllowThreads();
46401 wxSizer__setOORInfo(arg1,arg2);
46402 wxPyEndAllowThreads(__tstate);
46403 if (PyErr_Occurred()) SWIG_fail;
46404 }
46405 resultobj = SWIG_Py_Void();
46406 return resultobj;
46407 fail:
46408 return NULL;
46409 }
46410
46411
46412 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46413 PyObject *resultobj = 0;
46414 wxSizer *arg1 = (wxSizer *) 0 ;
46415 PyObject *arg2 = (PyObject *) 0 ;
46416 int arg3 = (int) 0 ;
46417 int arg4 = (int) 0 ;
46418 int arg5 = (int) 0 ;
46419 PyObject *arg6 = (PyObject *) NULL ;
46420 wxSizerItem *result = 0 ;
46421 void *argp1 = 0 ;
46422 int res1 = 0 ;
46423 int val3 ;
46424 int ecode3 = 0 ;
46425 int val4 ;
46426 int ecode4 = 0 ;
46427 int val5 ;
46428 int ecode5 = 0 ;
46429 PyObject * obj0 = 0 ;
46430 PyObject * obj1 = 0 ;
46431 PyObject * obj2 = 0 ;
46432 PyObject * obj3 = 0 ;
46433 PyObject * obj4 = 0 ;
46434 PyObject * obj5 = 0 ;
46435 char * kwnames[] = {
46436 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46437 };
46438
46439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46441 if (!SWIG_IsOK(res1)) {
46442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46443 }
46444 arg1 = reinterpret_cast< wxSizer * >(argp1);
46445 arg2 = obj1;
46446 if (obj2) {
46447 ecode3 = SWIG_AsVal_int(obj2, &val3);
46448 if (!SWIG_IsOK(ecode3)) {
46449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46450 }
46451 arg3 = static_cast< int >(val3);
46452 }
46453 if (obj3) {
46454 ecode4 = SWIG_AsVal_int(obj3, &val4);
46455 if (!SWIG_IsOK(ecode4)) {
46456 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46457 }
46458 arg4 = static_cast< int >(val4);
46459 }
46460 if (obj4) {
46461 ecode5 = SWIG_AsVal_int(obj4, &val5);
46462 if (!SWIG_IsOK(ecode5)) {
46463 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46464 }
46465 arg5 = static_cast< int >(val5);
46466 }
46467 if (obj5) {
46468 arg6 = obj5;
46469 }
46470 {
46471 PyThreadState* __tstate = wxPyBeginAllowThreads();
46472 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46473 wxPyEndAllowThreads(__tstate);
46474 if (PyErr_Occurred()) SWIG_fail;
46475 }
46476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46477 return resultobj;
46478 fail:
46479 return NULL;
46480 }
46481
46482
46483 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46484 PyObject *resultobj = 0;
46485 wxSizer *arg1 = (wxSizer *) 0 ;
46486 int arg2 ;
46487 PyObject *arg3 = (PyObject *) 0 ;
46488 int arg4 = (int) 0 ;
46489 int arg5 = (int) 0 ;
46490 int arg6 = (int) 0 ;
46491 PyObject *arg7 = (PyObject *) NULL ;
46492 wxSizerItem *result = 0 ;
46493 void *argp1 = 0 ;
46494 int res1 = 0 ;
46495 int val2 ;
46496 int ecode2 = 0 ;
46497 int val4 ;
46498 int ecode4 = 0 ;
46499 int val5 ;
46500 int ecode5 = 0 ;
46501 int val6 ;
46502 int ecode6 = 0 ;
46503 PyObject * obj0 = 0 ;
46504 PyObject * obj1 = 0 ;
46505 PyObject * obj2 = 0 ;
46506 PyObject * obj3 = 0 ;
46507 PyObject * obj4 = 0 ;
46508 PyObject * obj5 = 0 ;
46509 PyObject * obj6 = 0 ;
46510 char * kwnames[] = {
46511 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46512 };
46513
46514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46516 if (!SWIG_IsOK(res1)) {
46517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46518 }
46519 arg1 = reinterpret_cast< wxSizer * >(argp1);
46520 ecode2 = SWIG_AsVal_int(obj1, &val2);
46521 if (!SWIG_IsOK(ecode2)) {
46522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46523 }
46524 arg2 = static_cast< int >(val2);
46525 arg3 = obj2;
46526 if (obj3) {
46527 ecode4 = SWIG_AsVal_int(obj3, &val4);
46528 if (!SWIG_IsOK(ecode4)) {
46529 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46530 }
46531 arg4 = static_cast< int >(val4);
46532 }
46533 if (obj4) {
46534 ecode5 = SWIG_AsVal_int(obj4, &val5);
46535 if (!SWIG_IsOK(ecode5)) {
46536 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46537 }
46538 arg5 = static_cast< int >(val5);
46539 }
46540 if (obj5) {
46541 ecode6 = SWIG_AsVal_int(obj5, &val6);
46542 if (!SWIG_IsOK(ecode6)) {
46543 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46544 }
46545 arg6 = static_cast< int >(val6);
46546 }
46547 if (obj6) {
46548 arg7 = obj6;
46549 }
46550 {
46551 PyThreadState* __tstate = wxPyBeginAllowThreads();
46552 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46553 wxPyEndAllowThreads(__tstate);
46554 if (PyErr_Occurred()) SWIG_fail;
46555 }
46556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46557 return resultobj;
46558 fail:
46559 return NULL;
46560 }
46561
46562
46563 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46564 PyObject *resultobj = 0;
46565 wxSizer *arg1 = (wxSizer *) 0 ;
46566 PyObject *arg2 = (PyObject *) 0 ;
46567 int arg3 = (int) 0 ;
46568 int arg4 = (int) 0 ;
46569 int arg5 = (int) 0 ;
46570 PyObject *arg6 = (PyObject *) NULL ;
46571 wxSizerItem *result = 0 ;
46572 void *argp1 = 0 ;
46573 int res1 = 0 ;
46574 int val3 ;
46575 int ecode3 = 0 ;
46576 int val4 ;
46577 int ecode4 = 0 ;
46578 int val5 ;
46579 int ecode5 = 0 ;
46580 PyObject * obj0 = 0 ;
46581 PyObject * obj1 = 0 ;
46582 PyObject * obj2 = 0 ;
46583 PyObject * obj3 = 0 ;
46584 PyObject * obj4 = 0 ;
46585 PyObject * obj5 = 0 ;
46586 char * kwnames[] = {
46587 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46588 };
46589
46590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46592 if (!SWIG_IsOK(res1)) {
46593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46594 }
46595 arg1 = reinterpret_cast< wxSizer * >(argp1);
46596 arg2 = obj1;
46597 if (obj2) {
46598 ecode3 = SWIG_AsVal_int(obj2, &val3);
46599 if (!SWIG_IsOK(ecode3)) {
46600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46601 }
46602 arg3 = static_cast< int >(val3);
46603 }
46604 if (obj3) {
46605 ecode4 = SWIG_AsVal_int(obj3, &val4);
46606 if (!SWIG_IsOK(ecode4)) {
46607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46608 }
46609 arg4 = static_cast< int >(val4);
46610 }
46611 if (obj4) {
46612 ecode5 = SWIG_AsVal_int(obj4, &val5);
46613 if (!SWIG_IsOK(ecode5)) {
46614 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46615 }
46616 arg5 = static_cast< int >(val5);
46617 }
46618 if (obj5) {
46619 arg6 = obj5;
46620 }
46621 {
46622 PyThreadState* __tstate = wxPyBeginAllowThreads();
46623 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46624 wxPyEndAllowThreads(__tstate);
46625 if (PyErr_Occurred()) SWIG_fail;
46626 }
46627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46628 return resultobj;
46629 fail:
46630 return NULL;
46631 }
46632
46633
46634 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46635 PyObject *resultobj = 0;
46636 wxSizer *arg1 = (wxSizer *) 0 ;
46637 PyObject *arg2 = (PyObject *) 0 ;
46638 bool result;
46639 void *argp1 = 0 ;
46640 int res1 = 0 ;
46641 PyObject * obj0 = 0 ;
46642 PyObject * obj1 = 0 ;
46643 char * kwnames[] = {
46644 (char *) "self",(char *) "item", NULL
46645 };
46646
46647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46649 if (!SWIG_IsOK(res1)) {
46650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46651 }
46652 arg1 = reinterpret_cast< wxSizer * >(argp1);
46653 arg2 = obj1;
46654 {
46655 PyThreadState* __tstate = wxPyBeginAllowThreads();
46656 result = (bool)wxSizer_Remove(arg1,arg2);
46657 wxPyEndAllowThreads(__tstate);
46658 if (PyErr_Occurred()) SWIG_fail;
46659 }
46660 {
46661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46662 }
46663 return resultobj;
46664 fail:
46665 return NULL;
46666 }
46667
46668
46669 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46670 PyObject *resultobj = 0;
46671 wxSizer *arg1 = (wxSizer *) 0 ;
46672 PyObject *arg2 = (PyObject *) 0 ;
46673 bool result;
46674 void *argp1 = 0 ;
46675 int res1 = 0 ;
46676 PyObject * obj0 = 0 ;
46677 PyObject * obj1 = 0 ;
46678 char * kwnames[] = {
46679 (char *) "self",(char *) "item", NULL
46680 };
46681
46682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46684 if (!SWIG_IsOK(res1)) {
46685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46686 }
46687 arg1 = reinterpret_cast< wxSizer * >(argp1);
46688 arg2 = obj1;
46689 {
46690 PyThreadState* __tstate = wxPyBeginAllowThreads();
46691 result = (bool)wxSizer_Detach(arg1,arg2);
46692 wxPyEndAllowThreads(__tstate);
46693 if (PyErr_Occurred()) SWIG_fail;
46694 }
46695 {
46696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46697 }
46698 return resultobj;
46699 fail:
46700 return NULL;
46701 }
46702
46703
46704 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46705 PyObject *resultobj = 0;
46706 wxSizer *arg1 = (wxSizer *) 0 ;
46707 PyObject *arg2 = (PyObject *) 0 ;
46708 wxSizerItem *result = 0 ;
46709 void *argp1 = 0 ;
46710 int res1 = 0 ;
46711 PyObject * obj0 = 0 ;
46712 PyObject * obj1 = 0 ;
46713 char * kwnames[] = {
46714 (char *) "self",(char *) "item", NULL
46715 };
46716
46717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46719 if (!SWIG_IsOK(res1)) {
46720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46721 }
46722 arg1 = reinterpret_cast< wxSizer * >(argp1);
46723 arg2 = obj1;
46724 {
46725 PyThreadState* __tstate = wxPyBeginAllowThreads();
46726 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46727 wxPyEndAllowThreads(__tstate);
46728 if (PyErr_Occurred()) SWIG_fail;
46729 }
46730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46731 return resultobj;
46732 fail:
46733 return NULL;
46734 }
46735
46736
46737 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46738 PyObject *resultobj = 0;
46739 wxSizer *arg1 = (wxSizer *) 0 ;
46740 PyObject *arg2 = (PyObject *) 0 ;
46741 wxSize *arg3 = 0 ;
46742 void *argp1 = 0 ;
46743 int res1 = 0 ;
46744 wxSize temp3 ;
46745 PyObject * obj0 = 0 ;
46746 PyObject * obj1 = 0 ;
46747 PyObject * obj2 = 0 ;
46748 char * kwnames[] = {
46749 (char *) "self",(char *) "item",(char *) "size", NULL
46750 };
46751
46752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46754 if (!SWIG_IsOK(res1)) {
46755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46756 }
46757 arg1 = reinterpret_cast< wxSizer * >(argp1);
46758 arg2 = obj1;
46759 {
46760 arg3 = &temp3;
46761 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46762 }
46763 {
46764 PyThreadState* __tstate = wxPyBeginAllowThreads();
46765 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46766 wxPyEndAllowThreads(__tstate);
46767 if (PyErr_Occurred()) SWIG_fail;
46768 }
46769 resultobj = SWIG_Py_Void();
46770 return resultobj;
46771 fail:
46772 return NULL;
46773 }
46774
46775
46776 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46777 PyObject *resultobj = 0;
46778 wxSizer *arg1 = (wxSizer *) 0 ;
46779 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46780 wxSizerItem *result = 0 ;
46781 void *argp1 = 0 ;
46782 int res1 = 0 ;
46783 int res2 = 0 ;
46784 PyObject * obj0 = 0 ;
46785 PyObject * obj1 = 0 ;
46786 char * kwnames[] = {
46787 (char *) "self",(char *) "item", NULL
46788 };
46789
46790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46792 if (!SWIG_IsOK(res1)) {
46793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46794 }
46795 arg1 = reinterpret_cast< wxSizer * >(argp1);
46796 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46797 if (!SWIG_IsOK(res2)) {
46798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46799 }
46800 {
46801 PyThreadState* __tstate = wxPyBeginAllowThreads();
46802 result = (wxSizerItem *)(arg1)->Add(arg2);
46803 wxPyEndAllowThreads(__tstate);
46804 if (PyErr_Occurred()) SWIG_fail;
46805 }
46806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46807 return resultobj;
46808 fail:
46809 return NULL;
46810 }
46811
46812
46813 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46814 PyObject *resultobj = 0;
46815 wxSizer *arg1 = (wxSizer *) 0 ;
46816 size_t arg2 ;
46817 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46818 wxSizerItem *result = 0 ;
46819 void *argp1 = 0 ;
46820 int res1 = 0 ;
46821 size_t val2 ;
46822 int ecode2 = 0 ;
46823 int res3 = 0 ;
46824 PyObject * obj0 = 0 ;
46825 PyObject * obj1 = 0 ;
46826 PyObject * obj2 = 0 ;
46827 char * kwnames[] = {
46828 (char *) "self",(char *) "index",(char *) "item", NULL
46829 };
46830
46831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46833 if (!SWIG_IsOK(res1)) {
46834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46835 }
46836 arg1 = reinterpret_cast< wxSizer * >(argp1);
46837 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46838 if (!SWIG_IsOK(ecode2)) {
46839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46840 }
46841 arg2 = static_cast< size_t >(val2);
46842 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46843 if (!SWIG_IsOK(res3)) {
46844 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46845 }
46846 {
46847 PyThreadState* __tstate = wxPyBeginAllowThreads();
46848 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46849 wxPyEndAllowThreads(__tstate);
46850 if (PyErr_Occurred()) SWIG_fail;
46851 }
46852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46853 return resultobj;
46854 fail:
46855 return NULL;
46856 }
46857
46858
46859 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46860 PyObject *resultobj = 0;
46861 wxSizer *arg1 = (wxSizer *) 0 ;
46862 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46863 wxSizerItem *result = 0 ;
46864 void *argp1 = 0 ;
46865 int res1 = 0 ;
46866 int res2 = 0 ;
46867 PyObject * obj0 = 0 ;
46868 PyObject * obj1 = 0 ;
46869 char * kwnames[] = {
46870 (char *) "self",(char *) "item", NULL
46871 };
46872
46873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46875 if (!SWIG_IsOK(res1)) {
46876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46877 }
46878 arg1 = reinterpret_cast< wxSizer * >(argp1);
46879 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46880 if (!SWIG_IsOK(res2)) {
46881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46882 }
46883 {
46884 PyThreadState* __tstate = wxPyBeginAllowThreads();
46885 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46886 wxPyEndAllowThreads(__tstate);
46887 if (PyErr_Occurred()) SWIG_fail;
46888 }
46889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46890 return resultobj;
46891 fail:
46892 return NULL;
46893 }
46894
46895
46896 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46897 PyObject *resultobj = 0;
46898 wxSizer *arg1 = (wxSizer *) 0 ;
46899 int arg2 ;
46900 int arg3 ;
46901 int arg4 ;
46902 int arg5 ;
46903 void *argp1 = 0 ;
46904 int res1 = 0 ;
46905 int val2 ;
46906 int ecode2 = 0 ;
46907 int val3 ;
46908 int ecode3 = 0 ;
46909 int val4 ;
46910 int ecode4 = 0 ;
46911 int val5 ;
46912 int ecode5 = 0 ;
46913 PyObject * obj0 = 0 ;
46914 PyObject * obj1 = 0 ;
46915 PyObject * obj2 = 0 ;
46916 PyObject * obj3 = 0 ;
46917 PyObject * obj4 = 0 ;
46918 char * kwnames[] = {
46919 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46920 };
46921
46922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46924 if (!SWIG_IsOK(res1)) {
46925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46926 }
46927 arg1 = reinterpret_cast< wxSizer * >(argp1);
46928 ecode2 = SWIG_AsVal_int(obj1, &val2);
46929 if (!SWIG_IsOK(ecode2)) {
46930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46931 }
46932 arg2 = static_cast< int >(val2);
46933 ecode3 = SWIG_AsVal_int(obj2, &val3);
46934 if (!SWIG_IsOK(ecode3)) {
46935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46936 }
46937 arg3 = static_cast< int >(val3);
46938 ecode4 = SWIG_AsVal_int(obj3, &val4);
46939 if (!SWIG_IsOK(ecode4)) {
46940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46941 }
46942 arg4 = static_cast< int >(val4);
46943 ecode5 = SWIG_AsVal_int(obj4, &val5);
46944 if (!SWIG_IsOK(ecode5)) {
46945 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46946 }
46947 arg5 = static_cast< int >(val5);
46948 {
46949 PyThreadState* __tstate = wxPyBeginAllowThreads();
46950 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46951 wxPyEndAllowThreads(__tstate);
46952 if (PyErr_Occurred()) SWIG_fail;
46953 }
46954 resultobj = SWIG_Py_Void();
46955 return resultobj;
46956 fail:
46957 return NULL;
46958 }
46959
46960
46961 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46962 PyObject *resultobj = 0;
46963 wxSizer *arg1 = (wxSizer *) 0 ;
46964 wxSize *arg2 = 0 ;
46965 void *argp1 = 0 ;
46966 int res1 = 0 ;
46967 wxSize temp2 ;
46968 PyObject * obj0 = 0 ;
46969 PyObject * obj1 = 0 ;
46970 char * kwnames[] = {
46971 (char *) "self",(char *) "size", NULL
46972 };
46973
46974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46976 if (!SWIG_IsOK(res1)) {
46977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46978 }
46979 arg1 = reinterpret_cast< wxSizer * >(argp1);
46980 {
46981 arg2 = &temp2;
46982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46983 }
46984 {
46985 PyThreadState* __tstate = wxPyBeginAllowThreads();
46986 (arg1)->SetMinSize((wxSize const &)*arg2);
46987 wxPyEndAllowThreads(__tstate);
46988 if (PyErr_Occurred()) SWIG_fail;
46989 }
46990 resultobj = SWIG_Py_Void();
46991 return resultobj;
46992 fail:
46993 return NULL;
46994 }
46995
46996
46997 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46998 PyObject *resultobj = 0;
46999 wxSizer *arg1 = (wxSizer *) 0 ;
47000 wxSize result;
47001 void *argp1 = 0 ;
47002 int res1 = 0 ;
47003 PyObject *swig_obj[1] ;
47004
47005 if (!args) SWIG_fail;
47006 swig_obj[0] = args;
47007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47008 if (!SWIG_IsOK(res1)) {
47009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47010 }
47011 arg1 = reinterpret_cast< wxSizer * >(argp1);
47012 {
47013 PyThreadState* __tstate = wxPyBeginAllowThreads();
47014 result = (arg1)->GetSize();
47015 wxPyEndAllowThreads(__tstate);
47016 if (PyErr_Occurred()) SWIG_fail;
47017 }
47018 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47019 return resultobj;
47020 fail:
47021 return NULL;
47022 }
47023
47024
47025 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47026 PyObject *resultobj = 0;
47027 wxSizer *arg1 = (wxSizer *) 0 ;
47028 wxPoint result;
47029 void *argp1 = 0 ;
47030 int res1 = 0 ;
47031 PyObject *swig_obj[1] ;
47032
47033 if (!args) SWIG_fail;
47034 swig_obj[0] = args;
47035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47036 if (!SWIG_IsOK(res1)) {
47037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47038 }
47039 arg1 = reinterpret_cast< wxSizer * >(argp1);
47040 {
47041 PyThreadState* __tstate = wxPyBeginAllowThreads();
47042 result = (arg1)->GetPosition();
47043 wxPyEndAllowThreads(__tstate);
47044 if (PyErr_Occurred()) SWIG_fail;
47045 }
47046 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47047 return resultobj;
47048 fail:
47049 return NULL;
47050 }
47051
47052
47053 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47054 PyObject *resultobj = 0;
47055 wxSizer *arg1 = (wxSizer *) 0 ;
47056 wxSize result;
47057 void *argp1 = 0 ;
47058 int res1 = 0 ;
47059 PyObject *swig_obj[1] ;
47060
47061 if (!args) SWIG_fail;
47062 swig_obj[0] = args;
47063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47064 if (!SWIG_IsOK(res1)) {
47065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47066 }
47067 arg1 = reinterpret_cast< wxSizer * >(argp1);
47068 {
47069 PyThreadState* __tstate = wxPyBeginAllowThreads();
47070 result = (arg1)->GetMinSize();
47071 wxPyEndAllowThreads(__tstate);
47072 if (PyErr_Occurred()) SWIG_fail;
47073 }
47074 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47075 return resultobj;
47076 fail:
47077 return NULL;
47078 }
47079
47080
47081 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47082 PyObject *resultobj = 0;
47083 wxSizer *arg1 = (wxSizer *) 0 ;
47084 void *argp1 = 0 ;
47085 int res1 = 0 ;
47086 PyObject *swig_obj[1] ;
47087
47088 if (!args) SWIG_fail;
47089 swig_obj[0] = args;
47090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47091 if (!SWIG_IsOK(res1)) {
47092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47093 }
47094 arg1 = reinterpret_cast< wxSizer * >(argp1);
47095 {
47096 PyThreadState* __tstate = wxPyBeginAllowThreads();
47097 (arg1)->RecalcSizes();
47098 wxPyEndAllowThreads(__tstate);
47099 if (PyErr_Occurred()) SWIG_fail;
47100 }
47101 resultobj = SWIG_Py_Void();
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47109 PyObject *resultobj = 0;
47110 wxSizer *arg1 = (wxSizer *) 0 ;
47111 wxSize result;
47112 void *argp1 = 0 ;
47113 int res1 = 0 ;
47114 PyObject *swig_obj[1] ;
47115
47116 if (!args) SWIG_fail;
47117 swig_obj[0] = args;
47118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47119 if (!SWIG_IsOK(res1)) {
47120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47121 }
47122 arg1 = reinterpret_cast< wxSizer * >(argp1);
47123 {
47124 PyThreadState* __tstate = wxPyBeginAllowThreads();
47125 result = (arg1)->CalcMin();
47126 wxPyEndAllowThreads(__tstate);
47127 if (PyErr_Occurred()) SWIG_fail;
47128 }
47129 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47130 return resultobj;
47131 fail:
47132 return NULL;
47133 }
47134
47135
47136 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47137 PyObject *resultobj = 0;
47138 wxSizer *arg1 = (wxSizer *) 0 ;
47139 void *argp1 = 0 ;
47140 int res1 = 0 ;
47141 PyObject *swig_obj[1] ;
47142
47143 if (!args) SWIG_fail;
47144 swig_obj[0] = args;
47145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47146 if (!SWIG_IsOK(res1)) {
47147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47148 }
47149 arg1 = reinterpret_cast< wxSizer * >(argp1);
47150 {
47151 PyThreadState* __tstate = wxPyBeginAllowThreads();
47152 (arg1)->Layout();
47153 wxPyEndAllowThreads(__tstate);
47154 if (PyErr_Occurred()) SWIG_fail;
47155 }
47156 resultobj = SWIG_Py_Void();
47157 return resultobj;
47158 fail:
47159 return NULL;
47160 }
47161
47162
47163 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47164 PyObject *resultobj = 0;
47165 wxSizer *arg1 = (wxSizer *) 0 ;
47166 wxWindow *arg2 = (wxWindow *) 0 ;
47167 wxSize result;
47168 void *argp1 = 0 ;
47169 int res1 = 0 ;
47170 void *argp2 = 0 ;
47171 int res2 = 0 ;
47172 PyObject * obj0 = 0 ;
47173 PyObject * obj1 = 0 ;
47174 char * kwnames[] = {
47175 (char *) "self",(char *) "window", NULL
47176 };
47177
47178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47180 if (!SWIG_IsOK(res1)) {
47181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47182 }
47183 arg1 = reinterpret_cast< wxSizer * >(argp1);
47184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47185 if (!SWIG_IsOK(res2)) {
47186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47187 }
47188 arg2 = reinterpret_cast< wxWindow * >(argp2);
47189 {
47190 PyThreadState* __tstate = wxPyBeginAllowThreads();
47191 result = (arg1)->Fit(arg2);
47192 wxPyEndAllowThreads(__tstate);
47193 if (PyErr_Occurred()) SWIG_fail;
47194 }
47195 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47196 return resultobj;
47197 fail:
47198 return NULL;
47199 }
47200
47201
47202 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47203 PyObject *resultobj = 0;
47204 wxSizer *arg1 = (wxSizer *) 0 ;
47205 wxWindow *arg2 = (wxWindow *) 0 ;
47206 void *argp1 = 0 ;
47207 int res1 = 0 ;
47208 void *argp2 = 0 ;
47209 int res2 = 0 ;
47210 PyObject * obj0 = 0 ;
47211 PyObject * obj1 = 0 ;
47212 char * kwnames[] = {
47213 (char *) "self",(char *) "window", NULL
47214 };
47215
47216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47218 if (!SWIG_IsOK(res1)) {
47219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47220 }
47221 arg1 = reinterpret_cast< wxSizer * >(argp1);
47222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47223 if (!SWIG_IsOK(res2)) {
47224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47225 }
47226 arg2 = reinterpret_cast< wxWindow * >(argp2);
47227 {
47228 PyThreadState* __tstate = wxPyBeginAllowThreads();
47229 (arg1)->FitInside(arg2);
47230 wxPyEndAllowThreads(__tstate);
47231 if (PyErr_Occurred()) SWIG_fail;
47232 }
47233 resultobj = SWIG_Py_Void();
47234 return resultobj;
47235 fail:
47236 return NULL;
47237 }
47238
47239
47240 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47241 PyObject *resultobj = 0;
47242 wxSizer *arg1 = (wxSizer *) 0 ;
47243 wxWindow *arg2 = (wxWindow *) 0 ;
47244 void *argp1 = 0 ;
47245 int res1 = 0 ;
47246 void *argp2 = 0 ;
47247 int res2 = 0 ;
47248 PyObject * obj0 = 0 ;
47249 PyObject * obj1 = 0 ;
47250 char * kwnames[] = {
47251 (char *) "self",(char *) "window", NULL
47252 };
47253
47254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47256 if (!SWIG_IsOK(res1)) {
47257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47258 }
47259 arg1 = reinterpret_cast< wxSizer * >(argp1);
47260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47261 if (!SWIG_IsOK(res2)) {
47262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47263 }
47264 arg2 = reinterpret_cast< wxWindow * >(argp2);
47265 {
47266 PyThreadState* __tstate = wxPyBeginAllowThreads();
47267 (arg1)->SetSizeHints(arg2);
47268 wxPyEndAllowThreads(__tstate);
47269 if (PyErr_Occurred()) SWIG_fail;
47270 }
47271 resultobj = SWIG_Py_Void();
47272 return resultobj;
47273 fail:
47274 return NULL;
47275 }
47276
47277
47278 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47279 PyObject *resultobj = 0;
47280 wxSizer *arg1 = (wxSizer *) 0 ;
47281 wxWindow *arg2 = (wxWindow *) 0 ;
47282 void *argp1 = 0 ;
47283 int res1 = 0 ;
47284 void *argp2 = 0 ;
47285 int res2 = 0 ;
47286 PyObject * obj0 = 0 ;
47287 PyObject * obj1 = 0 ;
47288 char * kwnames[] = {
47289 (char *) "self",(char *) "window", NULL
47290 };
47291
47292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47294 if (!SWIG_IsOK(res1)) {
47295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47296 }
47297 arg1 = reinterpret_cast< wxSizer * >(argp1);
47298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47299 if (!SWIG_IsOK(res2)) {
47300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47301 }
47302 arg2 = reinterpret_cast< wxWindow * >(argp2);
47303 {
47304 PyThreadState* __tstate = wxPyBeginAllowThreads();
47305 (arg1)->SetVirtualSizeHints(arg2);
47306 wxPyEndAllowThreads(__tstate);
47307 if (PyErr_Occurred()) SWIG_fail;
47308 }
47309 resultobj = SWIG_Py_Void();
47310 return resultobj;
47311 fail:
47312 return NULL;
47313 }
47314
47315
47316 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47317 PyObject *resultobj = 0;
47318 wxSizer *arg1 = (wxSizer *) 0 ;
47319 bool arg2 = (bool) false ;
47320 void *argp1 = 0 ;
47321 int res1 = 0 ;
47322 bool val2 ;
47323 int ecode2 = 0 ;
47324 PyObject * obj0 = 0 ;
47325 PyObject * obj1 = 0 ;
47326 char * kwnames[] = {
47327 (char *) "self",(char *) "deleteWindows", NULL
47328 };
47329
47330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47332 if (!SWIG_IsOK(res1)) {
47333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47334 }
47335 arg1 = reinterpret_cast< wxSizer * >(argp1);
47336 if (obj1) {
47337 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47338 if (!SWIG_IsOK(ecode2)) {
47339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47340 }
47341 arg2 = static_cast< bool >(val2);
47342 }
47343 {
47344 PyThreadState* __tstate = wxPyBeginAllowThreads();
47345 (arg1)->Clear(arg2);
47346 wxPyEndAllowThreads(__tstate);
47347 if (PyErr_Occurred()) SWIG_fail;
47348 }
47349 resultobj = SWIG_Py_Void();
47350 return resultobj;
47351 fail:
47352 return NULL;
47353 }
47354
47355
47356 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47357 PyObject *resultobj = 0;
47358 wxSizer *arg1 = (wxSizer *) 0 ;
47359 void *argp1 = 0 ;
47360 int res1 = 0 ;
47361 PyObject *swig_obj[1] ;
47362
47363 if (!args) SWIG_fail;
47364 swig_obj[0] = args;
47365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47366 if (!SWIG_IsOK(res1)) {
47367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47368 }
47369 arg1 = reinterpret_cast< wxSizer * >(argp1);
47370 {
47371 PyThreadState* __tstate = wxPyBeginAllowThreads();
47372 (arg1)->DeleteWindows();
47373 wxPyEndAllowThreads(__tstate);
47374 if (PyErr_Occurred()) SWIG_fail;
47375 }
47376 resultobj = SWIG_Py_Void();
47377 return resultobj;
47378 fail:
47379 return NULL;
47380 }
47381
47382
47383 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47384 PyObject *resultobj = 0;
47385 wxSizer *arg1 = (wxSizer *) 0 ;
47386 PyObject *result = 0 ;
47387 void *argp1 = 0 ;
47388 int res1 = 0 ;
47389 PyObject *swig_obj[1] ;
47390
47391 if (!args) SWIG_fail;
47392 swig_obj[0] = args;
47393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47394 if (!SWIG_IsOK(res1)) {
47395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47396 }
47397 arg1 = reinterpret_cast< wxSizer * >(argp1);
47398 {
47399 PyThreadState* __tstate = wxPyBeginAllowThreads();
47400 result = (PyObject *)wxSizer_GetChildren(arg1);
47401 wxPyEndAllowThreads(__tstate);
47402 if (PyErr_Occurred()) SWIG_fail;
47403 }
47404 resultobj = result;
47405 return resultobj;
47406 fail:
47407 return NULL;
47408 }
47409
47410
47411 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47412 PyObject *resultobj = 0;
47413 wxSizer *arg1 = (wxSizer *) 0 ;
47414 PyObject *arg2 = (PyObject *) 0 ;
47415 bool arg3 = (bool) true ;
47416 bool arg4 = (bool) false ;
47417 bool result;
47418 void *argp1 = 0 ;
47419 int res1 = 0 ;
47420 bool val3 ;
47421 int ecode3 = 0 ;
47422 bool val4 ;
47423 int ecode4 = 0 ;
47424 PyObject * obj0 = 0 ;
47425 PyObject * obj1 = 0 ;
47426 PyObject * obj2 = 0 ;
47427 PyObject * obj3 = 0 ;
47428 char * kwnames[] = {
47429 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47430 };
47431
47432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47434 if (!SWIG_IsOK(res1)) {
47435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47436 }
47437 arg1 = reinterpret_cast< wxSizer * >(argp1);
47438 arg2 = obj1;
47439 if (obj2) {
47440 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47441 if (!SWIG_IsOK(ecode3)) {
47442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47443 }
47444 arg3 = static_cast< bool >(val3);
47445 }
47446 if (obj3) {
47447 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47448 if (!SWIG_IsOK(ecode4)) {
47449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47450 }
47451 arg4 = static_cast< bool >(val4);
47452 }
47453 {
47454 PyThreadState* __tstate = wxPyBeginAllowThreads();
47455 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47456 wxPyEndAllowThreads(__tstate);
47457 if (PyErr_Occurred()) SWIG_fail;
47458 }
47459 {
47460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47461 }
47462 return resultobj;
47463 fail:
47464 return NULL;
47465 }
47466
47467
47468 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47469 PyObject *resultobj = 0;
47470 wxSizer *arg1 = (wxSizer *) 0 ;
47471 PyObject *arg2 = (PyObject *) 0 ;
47472 bool result;
47473 void *argp1 = 0 ;
47474 int res1 = 0 ;
47475 PyObject * obj0 = 0 ;
47476 PyObject * obj1 = 0 ;
47477 char * kwnames[] = {
47478 (char *) "self",(char *) "item", NULL
47479 };
47480
47481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47483 if (!SWIG_IsOK(res1)) {
47484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47485 }
47486 arg1 = reinterpret_cast< wxSizer * >(argp1);
47487 arg2 = obj1;
47488 {
47489 PyThreadState* __tstate = wxPyBeginAllowThreads();
47490 result = (bool)wxSizer_IsShown(arg1,arg2);
47491 wxPyEndAllowThreads(__tstate);
47492 if (PyErr_Occurred()) SWIG_fail;
47493 }
47494 {
47495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47496 }
47497 return resultobj;
47498 fail:
47499 return NULL;
47500 }
47501
47502
47503 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47504 PyObject *resultobj = 0;
47505 wxSizer *arg1 = (wxSizer *) 0 ;
47506 bool arg2 ;
47507 void *argp1 = 0 ;
47508 int res1 = 0 ;
47509 bool val2 ;
47510 int ecode2 = 0 ;
47511 PyObject * obj0 = 0 ;
47512 PyObject * obj1 = 0 ;
47513 char * kwnames[] = {
47514 (char *) "self",(char *) "show", NULL
47515 };
47516
47517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47519 if (!SWIG_IsOK(res1)) {
47520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47521 }
47522 arg1 = reinterpret_cast< wxSizer * >(argp1);
47523 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47524 if (!SWIG_IsOK(ecode2)) {
47525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47526 }
47527 arg2 = static_cast< bool >(val2);
47528 {
47529 PyThreadState* __tstate = wxPyBeginAllowThreads();
47530 (arg1)->ShowItems(arg2);
47531 wxPyEndAllowThreads(__tstate);
47532 if (PyErr_Occurred()) SWIG_fail;
47533 }
47534 resultobj = SWIG_Py_Void();
47535 return resultobj;
47536 fail:
47537 return NULL;
47538 }
47539
47540
47541 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47542 PyObject *obj;
47543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47544 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47545 return SWIG_Py_Void();
47546 }
47547
47548 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47549 PyObject *resultobj = 0;
47550 wxPySizer *result = 0 ;
47551
47552 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47553 {
47554 PyThreadState* __tstate = wxPyBeginAllowThreads();
47555 result = (wxPySizer *)new wxPySizer();
47556 wxPyEndAllowThreads(__tstate);
47557 if (PyErr_Occurred()) SWIG_fail;
47558 }
47559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47560 return resultobj;
47561 fail:
47562 return NULL;
47563 }
47564
47565
47566 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47567 PyObject *resultobj = 0;
47568 wxPySizer *arg1 = (wxPySizer *) 0 ;
47569 PyObject *arg2 = (PyObject *) 0 ;
47570 PyObject *arg3 = (PyObject *) 0 ;
47571 void *argp1 = 0 ;
47572 int res1 = 0 ;
47573 PyObject * obj0 = 0 ;
47574 PyObject * obj1 = 0 ;
47575 PyObject * obj2 = 0 ;
47576 char * kwnames[] = {
47577 (char *) "self",(char *) "self",(char *) "_class", NULL
47578 };
47579
47580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47582 if (!SWIG_IsOK(res1)) {
47583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47584 }
47585 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47586 arg2 = obj1;
47587 arg3 = obj2;
47588 {
47589 PyThreadState* __tstate = wxPyBeginAllowThreads();
47590 (arg1)->_setCallbackInfo(arg2,arg3);
47591 wxPyEndAllowThreads(__tstate);
47592 if (PyErr_Occurred()) SWIG_fail;
47593 }
47594 resultobj = SWIG_Py_Void();
47595 return resultobj;
47596 fail:
47597 return NULL;
47598 }
47599
47600
47601 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47602 PyObject *obj;
47603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47604 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47605 return SWIG_Py_Void();
47606 }
47607
47608 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47609 return SWIG_Python_InitShadowInstance(args);
47610 }
47611
47612 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47613 PyObject *resultobj = 0;
47614 int arg1 = (int) wxHORIZONTAL ;
47615 wxBoxSizer *result = 0 ;
47616 int val1 ;
47617 int ecode1 = 0 ;
47618 PyObject * obj0 = 0 ;
47619 char * kwnames[] = {
47620 (char *) "orient", NULL
47621 };
47622
47623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47624 if (obj0) {
47625 ecode1 = SWIG_AsVal_int(obj0, &val1);
47626 if (!SWIG_IsOK(ecode1)) {
47627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47628 }
47629 arg1 = static_cast< int >(val1);
47630 }
47631 {
47632 PyThreadState* __tstate = wxPyBeginAllowThreads();
47633 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47634 wxPyEndAllowThreads(__tstate);
47635 if (PyErr_Occurred()) SWIG_fail;
47636 }
47637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47638 return resultobj;
47639 fail:
47640 return NULL;
47641 }
47642
47643
47644 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47645 PyObject *resultobj = 0;
47646 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47647 int result;
47648 void *argp1 = 0 ;
47649 int res1 = 0 ;
47650 PyObject *swig_obj[1] ;
47651
47652 if (!args) SWIG_fail;
47653 swig_obj[0] = args;
47654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47655 if (!SWIG_IsOK(res1)) {
47656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47657 }
47658 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47659 {
47660 PyThreadState* __tstate = wxPyBeginAllowThreads();
47661 result = (int)(arg1)->GetOrientation();
47662 wxPyEndAllowThreads(__tstate);
47663 if (PyErr_Occurred()) SWIG_fail;
47664 }
47665 resultobj = SWIG_From_int(static_cast< int >(result));
47666 return resultobj;
47667 fail:
47668 return NULL;
47669 }
47670
47671
47672 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47673 PyObject *resultobj = 0;
47674 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47675 int arg2 ;
47676 void *argp1 = 0 ;
47677 int res1 = 0 ;
47678 int val2 ;
47679 int ecode2 = 0 ;
47680 PyObject * obj0 = 0 ;
47681 PyObject * obj1 = 0 ;
47682 char * kwnames[] = {
47683 (char *) "self",(char *) "orient", NULL
47684 };
47685
47686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47688 if (!SWIG_IsOK(res1)) {
47689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47690 }
47691 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47692 ecode2 = SWIG_AsVal_int(obj1, &val2);
47693 if (!SWIG_IsOK(ecode2)) {
47694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47695 }
47696 arg2 = static_cast< int >(val2);
47697 {
47698 PyThreadState* __tstate = wxPyBeginAllowThreads();
47699 (arg1)->SetOrientation(arg2);
47700 wxPyEndAllowThreads(__tstate);
47701 if (PyErr_Occurred()) SWIG_fail;
47702 }
47703 resultobj = SWIG_Py_Void();
47704 return resultobj;
47705 fail:
47706 return NULL;
47707 }
47708
47709
47710 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47711 PyObject *obj;
47712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47713 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47714 return SWIG_Py_Void();
47715 }
47716
47717 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47718 return SWIG_Python_InitShadowInstance(args);
47719 }
47720
47721 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47722 PyObject *resultobj = 0;
47723 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47724 int arg2 = (int) wxHORIZONTAL ;
47725 wxStaticBoxSizer *result = 0 ;
47726 void *argp1 = 0 ;
47727 int res1 = 0 ;
47728 int val2 ;
47729 int ecode2 = 0 ;
47730 PyObject * obj0 = 0 ;
47731 PyObject * obj1 = 0 ;
47732 char * kwnames[] = {
47733 (char *) "box",(char *) "orient", NULL
47734 };
47735
47736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47738 if (!SWIG_IsOK(res1)) {
47739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47740 }
47741 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47742 if (obj1) {
47743 ecode2 = SWIG_AsVal_int(obj1, &val2);
47744 if (!SWIG_IsOK(ecode2)) {
47745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47746 }
47747 arg2 = static_cast< int >(val2);
47748 }
47749 {
47750 PyThreadState* __tstate = wxPyBeginAllowThreads();
47751 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47752 wxPyEndAllowThreads(__tstate);
47753 if (PyErr_Occurred()) SWIG_fail;
47754 }
47755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47756 return resultobj;
47757 fail:
47758 return NULL;
47759 }
47760
47761
47762 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47763 PyObject *resultobj = 0;
47764 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47765 wxStaticBox *result = 0 ;
47766 void *argp1 = 0 ;
47767 int res1 = 0 ;
47768 PyObject *swig_obj[1] ;
47769
47770 if (!args) SWIG_fail;
47771 swig_obj[0] = args;
47772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47773 if (!SWIG_IsOK(res1)) {
47774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47775 }
47776 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47777 {
47778 PyThreadState* __tstate = wxPyBeginAllowThreads();
47779 result = (wxStaticBox *)(arg1)->GetStaticBox();
47780 wxPyEndAllowThreads(__tstate);
47781 if (PyErr_Occurred()) SWIG_fail;
47782 }
47783 {
47784 resultobj = wxPyMake_wxObject(result, (bool)0);
47785 }
47786 return resultobj;
47787 fail:
47788 return NULL;
47789 }
47790
47791
47792 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47793 PyObject *obj;
47794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47795 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47796 return SWIG_Py_Void();
47797 }
47798
47799 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47800 return SWIG_Python_InitShadowInstance(args);
47801 }
47802
47803 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47804 PyObject *resultobj = 0;
47805 int arg1 = (int) 1 ;
47806 int arg2 = (int) 0 ;
47807 int arg3 = (int) 0 ;
47808 int arg4 = (int) 0 ;
47809 wxGridSizer *result = 0 ;
47810 int val1 ;
47811 int ecode1 = 0 ;
47812 int val2 ;
47813 int ecode2 = 0 ;
47814 int val3 ;
47815 int ecode3 = 0 ;
47816 int val4 ;
47817 int ecode4 = 0 ;
47818 PyObject * obj0 = 0 ;
47819 PyObject * obj1 = 0 ;
47820 PyObject * obj2 = 0 ;
47821 PyObject * obj3 = 0 ;
47822 char * kwnames[] = {
47823 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47824 };
47825
47826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47827 if (obj0) {
47828 ecode1 = SWIG_AsVal_int(obj0, &val1);
47829 if (!SWIG_IsOK(ecode1)) {
47830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47831 }
47832 arg1 = static_cast< int >(val1);
47833 }
47834 if (obj1) {
47835 ecode2 = SWIG_AsVal_int(obj1, &val2);
47836 if (!SWIG_IsOK(ecode2)) {
47837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47838 }
47839 arg2 = static_cast< int >(val2);
47840 }
47841 if (obj2) {
47842 ecode3 = SWIG_AsVal_int(obj2, &val3);
47843 if (!SWIG_IsOK(ecode3)) {
47844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47845 }
47846 arg3 = static_cast< int >(val3);
47847 }
47848 if (obj3) {
47849 ecode4 = SWIG_AsVal_int(obj3, &val4);
47850 if (!SWIG_IsOK(ecode4)) {
47851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47852 }
47853 arg4 = static_cast< int >(val4);
47854 }
47855 {
47856 PyThreadState* __tstate = wxPyBeginAllowThreads();
47857 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47858 wxPyEndAllowThreads(__tstate);
47859 if (PyErr_Occurred()) SWIG_fail;
47860 }
47861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47862 return resultobj;
47863 fail:
47864 return NULL;
47865 }
47866
47867
47868 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47869 PyObject *resultobj = 0;
47870 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47871 int arg2 ;
47872 void *argp1 = 0 ;
47873 int res1 = 0 ;
47874 int val2 ;
47875 int ecode2 = 0 ;
47876 PyObject * obj0 = 0 ;
47877 PyObject * obj1 = 0 ;
47878 char * kwnames[] = {
47879 (char *) "self",(char *) "cols", NULL
47880 };
47881
47882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47884 if (!SWIG_IsOK(res1)) {
47885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47886 }
47887 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47888 ecode2 = SWIG_AsVal_int(obj1, &val2);
47889 if (!SWIG_IsOK(ecode2)) {
47890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47891 }
47892 arg2 = static_cast< int >(val2);
47893 {
47894 PyThreadState* __tstate = wxPyBeginAllowThreads();
47895 (arg1)->SetCols(arg2);
47896 wxPyEndAllowThreads(__tstate);
47897 if (PyErr_Occurred()) SWIG_fail;
47898 }
47899 resultobj = SWIG_Py_Void();
47900 return resultobj;
47901 fail:
47902 return NULL;
47903 }
47904
47905
47906 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47907 PyObject *resultobj = 0;
47908 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47909 int arg2 ;
47910 void *argp1 = 0 ;
47911 int res1 = 0 ;
47912 int val2 ;
47913 int ecode2 = 0 ;
47914 PyObject * obj0 = 0 ;
47915 PyObject * obj1 = 0 ;
47916 char * kwnames[] = {
47917 (char *) "self",(char *) "rows", NULL
47918 };
47919
47920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47922 if (!SWIG_IsOK(res1)) {
47923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47924 }
47925 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47926 ecode2 = SWIG_AsVal_int(obj1, &val2);
47927 if (!SWIG_IsOK(ecode2)) {
47928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47929 }
47930 arg2 = static_cast< int >(val2);
47931 {
47932 PyThreadState* __tstate = wxPyBeginAllowThreads();
47933 (arg1)->SetRows(arg2);
47934 wxPyEndAllowThreads(__tstate);
47935 if (PyErr_Occurred()) SWIG_fail;
47936 }
47937 resultobj = SWIG_Py_Void();
47938 return resultobj;
47939 fail:
47940 return NULL;
47941 }
47942
47943
47944 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47945 PyObject *resultobj = 0;
47946 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47947 int arg2 ;
47948 void *argp1 = 0 ;
47949 int res1 = 0 ;
47950 int val2 ;
47951 int ecode2 = 0 ;
47952 PyObject * obj0 = 0 ;
47953 PyObject * obj1 = 0 ;
47954 char * kwnames[] = {
47955 (char *) "self",(char *) "gap", NULL
47956 };
47957
47958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47960 if (!SWIG_IsOK(res1)) {
47961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47962 }
47963 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47964 ecode2 = SWIG_AsVal_int(obj1, &val2);
47965 if (!SWIG_IsOK(ecode2)) {
47966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47967 }
47968 arg2 = static_cast< int >(val2);
47969 {
47970 PyThreadState* __tstate = wxPyBeginAllowThreads();
47971 (arg1)->SetVGap(arg2);
47972 wxPyEndAllowThreads(__tstate);
47973 if (PyErr_Occurred()) SWIG_fail;
47974 }
47975 resultobj = SWIG_Py_Void();
47976 return resultobj;
47977 fail:
47978 return NULL;
47979 }
47980
47981
47982 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47983 PyObject *resultobj = 0;
47984 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47985 int arg2 ;
47986 void *argp1 = 0 ;
47987 int res1 = 0 ;
47988 int val2 ;
47989 int ecode2 = 0 ;
47990 PyObject * obj0 = 0 ;
47991 PyObject * obj1 = 0 ;
47992 char * kwnames[] = {
47993 (char *) "self",(char *) "gap", NULL
47994 };
47995
47996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47998 if (!SWIG_IsOK(res1)) {
47999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48000 }
48001 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48002 ecode2 = SWIG_AsVal_int(obj1, &val2);
48003 if (!SWIG_IsOK(ecode2)) {
48004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48005 }
48006 arg2 = static_cast< int >(val2);
48007 {
48008 PyThreadState* __tstate = wxPyBeginAllowThreads();
48009 (arg1)->SetHGap(arg2);
48010 wxPyEndAllowThreads(__tstate);
48011 if (PyErr_Occurred()) SWIG_fail;
48012 }
48013 resultobj = SWIG_Py_Void();
48014 return resultobj;
48015 fail:
48016 return NULL;
48017 }
48018
48019
48020 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48021 PyObject *resultobj = 0;
48022 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48023 int result;
48024 void *argp1 = 0 ;
48025 int res1 = 0 ;
48026 PyObject *swig_obj[1] ;
48027
48028 if (!args) SWIG_fail;
48029 swig_obj[0] = args;
48030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48031 if (!SWIG_IsOK(res1)) {
48032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48033 }
48034 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48035 {
48036 PyThreadState* __tstate = wxPyBeginAllowThreads();
48037 result = (int)(arg1)->GetCols();
48038 wxPyEndAllowThreads(__tstate);
48039 if (PyErr_Occurred()) SWIG_fail;
48040 }
48041 resultobj = SWIG_From_int(static_cast< int >(result));
48042 return resultobj;
48043 fail:
48044 return NULL;
48045 }
48046
48047
48048 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48049 PyObject *resultobj = 0;
48050 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48051 int result;
48052 void *argp1 = 0 ;
48053 int res1 = 0 ;
48054 PyObject *swig_obj[1] ;
48055
48056 if (!args) SWIG_fail;
48057 swig_obj[0] = args;
48058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48059 if (!SWIG_IsOK(res1)) {
48060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48061 }
48062 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48063 {
48064 PyThreadState* __tstate = wxPyBeginAllowThreads();
48065 result = (int)(arg1)->GetRows();
48066 wxPyEndAllowThreads(__tstate);
48067 if (PyErr_Occurred()) SWIG_fail;
48068 }
48069 resultobj = SWIG_From_int(static_cast< int >(result));
48070 return resultobj;
48071 fail:
48072 return NULL;
48073 }
48074
48075
48076 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48077 PyObject *resultobj = 0;
48078 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48079 int result;
48080 void *argp1 = 0 ;
48081 int res1 = 0 ;
48082 PyObject *swig_obj[1] ;
48083
48084 if (!args) SWIG_fail;
48085 swig_obj[0] = args;
48086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48087 if (!SWIG_IsOK(res1)) {
48088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48089 }
48090 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48091 {
48092 PyThreadState* __tstate = wxPyBeginAllowThreads();
48093 result = (int)(arg1)->GetVGap();
48094 wxPyEndAllowThreads(__tstate);
48095 if (PyErr_Occurred()) SWIG_fail;
48096 }
48097 resultobj = SWIG_From_int(static_cast< int >(result));
48098 return resultobj;
48099 fail:
48100 return NULL;
48101 }
48102
48103
48104 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48105 PyObject *resultobj = 0;
48106 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48107 int result;
48108 void *argp1 = 0 ;
48109 int res1 = 0 ;
48110 PyObject *swig_obj[1] ;
48111
48112 if (!args) SWIG_fail;
48113 swig_obj[0] = args;
48114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48115 if (!SWIG_IsOK(res1)) {
48116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48117 }
48118 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48119 {
48120 PyThreadState* __tstate = wxPyBeginAllowThreads();
48121 result = (int)(arg1)->GetHGap();
48122 wxPyEndAllowThreads(__tstate);
48123 if (PyErr_Occurred()) SWIG_fail;
48124 }
48125 resultobj = SWIG_From_int(static_cast< int >(result));
48126 return resultobj;
48127 fail:
48128 return NULL;
48129 }
48130
48131
48132 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48133 PyObject *obj;
48134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48135 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48136 return SWIG_Py_Void();
48137 }
48138
48139 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48140 return SWIG_Python_InitShadowInstance(args);
48141 }
48142
48143 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48144 PyObject *resultobj = 0;
48145 int arg1 = (int) 1 ;
48146 int arg2 = (int) 0 ;
48147 int arg3 = (int) 0 ;
48148 int arg4 = (int) 0 ;
48149 wxFlexGridSizer *result = 0 ;
48150 int val1 ;
48151 int ecode1 = 0 ;
48152 int val2 ;
48153 int ecode2 = 0 ;
48154 int val3 ;
48155 int ecode3 = 0 ;
48156 int val4 ;
48157 int ecode4 = 0 ;
48158 PyObject * obj0 = 0 ;
48159 PyObject * obj1 = 0 ;
48160 PyObject * obj2 = 0 ;
48161 PyObject * obj3 = 0 ;
48162 char * kwnames[] = {
48163 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48164 };
48165
48166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48167 if (obj0) {
48168 ecode1 = SWIG_AsVal_int(obj0, &val1);
48169 if (!SWIG_IsOK(ecode1)) {
48170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48171 }
48172 arg1 = static_cast< int >(val1);
48173 }
48174 if (obj1) {
48175 ecode2 = SWIG_AsVal_int(obj1, &val2);
48176 if (!SWIG_IsOK(ecode2)) {
48177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48178 }
48179 arg2 = static_cast< int >(val2);
48180 }
48181 if (obj2) {
48182 ecode3 = SWIG_AsVal_int(obj2, &val3);
48183 if (!SWIG_IsOK(ecode3)) {
48184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48185 }
48186 arg3 = static_cast< int >(val3);
48187 }
48188 if (obj3) {
48189 ecode4 = SWIG_AsVal_int(obj3, &val4);
48190 if (!SWIG_IsOK(ecode4)) {
48191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48192 }
48193 arg4 = static_cast< int >(val4);
48194 }
48195 {
48196 PyThreadState* __tstate = wxPyBeginAllowThreads();
48197 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48198 wxPyEndAllowThreads(__tstate);
48199 if (PyErr_Occurred()) SWIG_fail;
48200 }
48201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48202 return resultobj;
48203 fail:
48204 return NULL;
48205 }
48206
48207
48208 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48209 PyObject *resultobj = 0;
48210 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48211 size_t arg2 ;
48212 int arg3 = (int) 0 ;
48213 void *argp1 = 0 ;
48214 int res1 = 0 ;
48215 size_t val2 ;
48216 int ecode2 = 0 ;
48217 int val3 ;
48218 int ecode3 = 0 ;
48219 PyObject * obj0 = 0 ;
48220 PyObject * obj1 = 0 ;
48221 PyObject * obj2 = 0 ;
48222 char * kwnames[] = {
48223 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48224 };
48225
48226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48228 if (!SWIG_IsOK(res1)) {
48229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48230 }
48231 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48232 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48233 if (!SWIG_IsOK(ecode2)) {
48234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48235 }
48236 arg2 = static_cast< size_t >(val2);
48237 if (obj2) {
48238 ecode3 = SWIG_AsVal_int(obj2, &val3);
48239 if (!SWIG_IsOK(ecode3)) {
48240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48241 }
48242 arg3 = static_cast< int >(val3);
48243 }
48244 {
48245 PyThreadState* __tstate = wxPyBeginAllowThreads();
48246 (arg1)->AddGrowableRow(arg2,arg3);
48247 wxPyEndAllowThreads(__tstate);
48248 if (PyErr_Occurred()) SWIG_fail;
48249 }
48250 resultobj = SWIG_Py_Void();
48251 return resultobj;
48252 fail:
48253 return NULL;
48254 }
48255
48256
48257 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48258 PyObject *resultobj = 0;
48259 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48260 size_t arg2 ;
48261 void *argp1 = 0 ;
48262 int res1 = 0 ;
48263 size_t val2 ;
48264 int ecode2 = 0 ;
48265 PyObject * obj0 = 0 ;
48266 PyObject * obj1 = 0 ;
48267 char * kwnames[] = {
48268 (char *) "self",(char *) "idx", NULL
48269 };
48270
48271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48273 if (!SWIG_IsOK(res1)) {
48274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48275 }
48276 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48277 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48278 if (!SWIG_IsOK(ecode2)) {
48279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48280 }
48281 arg2 = static_cast< size_t >(val2);
48282 {
48283 PyThreadState* __tstate = wxPyBeginAllowThreads();
48284 (arg1)->RemoveGrowableRow(arg2);
48285 wxPyEndAllowThreads(__tstate);
48286 if (PyErr_Occurred()) SWIG_fail;
48287 }
48288 resultobj = SWIG_Py_Void();
48289 return resultobj;
48290 fail:
48291 return NULL;
48292 }
48293
48294
48295 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48296 PyObject *resultobj = 0;
48297 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48298 size_t arg2 ;
48299 int arg3 = (int) 0 ;
48300 void *argp1 = 0 ;
48301 int res1 = 0 ;
48302 size_t val2 ;
48303 int ecode2 = 0 ;
48304 int val3 ;
48305 int ecode3 = 0 ;
48306 PyObject * obj0 = 0 ;
48307 PyObject * obj1 = 0 ;
48308 PyObject * obj2 = 0 ;
48309 char * kwnames[] = {
48310 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48311 };
48312
48313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48315 if (!SWIG_IsOK(res1)) {
48316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48317 }
48318 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48319 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48320 if (!SWIG_IsOK(ecode2)) {
48321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48322 }
48323 arg2 = static_cast< size_t >(val2);
48324 if (obj2) {
48325 ecode3 = SWIG_AsVal_int(obj2, &val3);
48326 if (!SWIG_IsOK(ecode3)) {
48327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48328 }
48329 arg3 = static_cast< int >(val3);
48330 }
48331 {
48332 PyThreadState* __tstate = wxPyBeginAllowThreads();
48333 (arg1)->AddGrowableCol(arg2,arg3);
48334 wxPyEndAllowThreads(__tstate);
48335 if (PyErr_Occurred()) SWIG_fail;
48336 }
48337 resultobj = SWIG_Py_Void();
48338 return resultobj;
48339 fail:
48340 return NULL;
48341 }
48342
48343
48344 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48345 PyObject *resultobj = 0;
48346 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48347 size_t arg2 ;
48348 void *argp1 = 0 ;
48349 int res1 = 0 ;
48350 size_t val2 ;
48351 int ecode2 = 0 ;
48352 PyObject * obj0 = 0 ;
48353 PyObject * obj1 = 0 ;
48354 char * kwnames[] = {
48355 (char *) "self",(char *) "idx", NULL
48356 };
48357
48358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48360 if (!SWIG_IsOK(res1)) {
48361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48362 }
48363 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48364 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48365 if (!SWIG_IsOK(ecode2)) {
48366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48367 }
48368 arg2 = static_cast< size_t >(val2);
48369 {
48370 PyThreadState* __tstate = wxPyBeginAllowThreads();
48371 (arg1)->RemoveGrowableCol(arg2);
48372 wxPyEndAllowThreads(__tstate);
48373 if (PyErr_Occurred()) SWIG_fail;
48374 }
48375 resultobj = SWIG_Py_Void();
48376 return resultobj;
48377 fail:
48378 return NULL;
48379 }
48380
48381
48382 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48383 PyObject *resultobj = 0;
48384 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48385 int arg2 ;
48386 void *argp1 = 0 ;
48387 int res1 = 0 ;
48388 int val2 ;
48389 int ecode2 = 0 ;
48390 PyObject * obj0 = 0 ;
48391 PyObject * obj1 = 0 ;
48392 char * kwnames[] = {
48393 (char *) "self",(char *) "direction", NULL
48394 };
48395
48396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48398 if (!SWIG_IsOK(res1)) {
48399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48400 }
48401 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48402 ecode2 = SWIG_AsVal_int(obj1, &val2);
48403 if (!SWIG_IsOK(ecode2)) {
48404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48405 }
48406 arg2 = static_cast< int >(val2);
48407 {
48408 PyThreadState* __tstate = wxPyBeginAllowThreads();
48409 (arg1)->SetFlexibleDirection(arg2);
48410 wxPyEndAllowThreads(__tstate);
48411 if (PyErr_Occurred()) SWIG_fail;
48412 }
48413 resultobj = SWIG_Py_Void();
48414 return resultobj;
48415 fail:
48416 return NULL;
48417 }
48418
48419
48420 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48421 PyObject *resultobj = 0;
48422 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48423 int result;
48424 void *argp1 = 0 ;
48425 int res1 = 0 ;
48426 PyObject *swig_obj[1] ;
48427
48428 if (!args) SWIG_fail;
48429 swig_obj[0] = args;
48430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48431 if (!SWIG_IsOK(res1)) {
48432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48433 }
48434 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48435 {
48436 PyThreadState* __tstate = wxPyBeginAllowThreads();
48437 result = (int)(arg1)->GetFlexibleDirection();
48438 wxPyEndAllowThreads(__tstate);
48439 if (PyErr_Occurred()) SWIG_fail;
48440 }
48441 resultobj = SWIG_From_int(static_cast< int >(result));
48442 return resultobj;
48443 fail:
48444 return NULL;
48445 }
48446
48447
48448 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48449 PyObject *resultobj = 0;
48450 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48451 wxFlexSizerGrowMode arg2 ;
48452 void *argp1 = 0 ;
48453 int res1 = 0 ;
48454 int val2 ;
48455 int ecode2 = 0 ;
48456 PyObject * obj0 = 0 ;
48457 PyObject * obj1 = 0 ;
48458 char * kwnames[] = {
48459 (char *) "self",(char *) "mode", NULL
48460 };
48461
48462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48464 if (!SWIG_IsOK(res1)) {
48465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48466 }
48467 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48468 ecode2 = SWIG_AsVal_int(obj1, &val2);
48469 if (!SWIG_IsOK(ecode2)) {
48470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48471 }
48472 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48473 {
48474 PyThreadState* __tstate = wxPyBeginAllowThreads();
48475 (arg1)->SetNonFlexibleGrowMode(arg2);
48476 wxPyEndAllowThreads(__tstate);
48477 if (PyErr_Occurred()) SWIG_fail;
48478 }
48479 resultobj = SWIG_Py_Void();
48480 return resultobj;
48481 fail:
48482 return NULL;
48483 }
48484
48485
48486 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48487 PyObject *resultobj = 0;
48488 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48489 wxFlexSizerGrowMode result;
48490 void *argp1 = 0 ;
48491 int res1 = 0 ;
48492 PyObject *swig_obj[1] ;
48493
48494 if (!args) SWIG_fail;
48495 swig_obj[0] = args;
48496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48497 if (!SWIG_IsOK(res1)) {
48498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48499 }
48500 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48501 {
48502 PyThreadState* __tstate = wxPyBeginAllowThreads();
48503 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48504 wxPyEndAllowThreads(__tstate);
48505 if (PyErr_Occurred()) SWIG_fail;
48506 }
48507 resultobj = SWIG_From_int(static_cast< int >(result));
48508 return resultobj;
48509 fail:
48510 return NULL;
48511 }
48512
48513
48514 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48515 PyObject *resultobj = 0;
48516 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48517 wxArrayInt *result = 0 ;
48518 void *argp1 = 0 ;
48519 int res1 = 0 ;
48520 PyObject *swig_obj[1] ;
48521
48522 if (!args) SWIG_fail;
48523 swig_obj[0] = args;
48524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48525 if (!SWIG_IsOK(res1)) {
48526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48527 }
48528 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48529 {
48530 PyThreadState* __tstate = wxPyBeginAllowThreads();
48531 {
48532 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48533 result = (wxArrayInt *) &_result_ref;
48534 }
48535 wxPyEndAllowThreads(__tstate);
48536 if (PyErr_Occurred()) SWIG_fail;
48537 }
48538 {
48539 resultobj = PyList_New(0);
48540 size_t idx;
48541 for (idx = 0; idx < result->GetCount(); idx += 1) {
48542 PyObject* val = PyInt_FromLong( result->Item(idx) );
48543 PyList_Append(resultobj, val);
48544 Py_DECREF(val);
48545 }
48546 }
48547 return resultobj;
48548 fail:
48549 return NULL;
48550 }
48551
48552
48553 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48554 PyObject *resultobj = 0;
48555 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48556 wxArrayInt *result = 0 ;
48557 void *argp1 = 0 ;
48558 int res1 = 0 ;
48559 PyObject *swig_obj[1] ;
48560
48561 if (!args) SWIG_fail;
48562 swig_obj[0] = args;
48563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48564 if (!SWIG_IsOK(res1)) {
48565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48566 }
48567 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48568 {
48569 PyThreadState* __tstate = wxPyBeginAllowThreads();
48570 {
48571 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48572 result = (wxArrayInt *) &_result_ref;
48573 }
48574 wxPyEndAllowThreads(__tstate);
48575 if (PyErr_Occurred()) SWIG_fail;
48576 }
48577 {
48578 resultobj = PyList_New(0);
48579 size_t idx;
48580 for (idx = 0; idx < result->GetCount(); idx += 1) {
48581 PyObject* val = PyInt_FromLong( result->Item(idx) );
48582 PyList_Append(resultobj, val);
48583 Py_DECREF(val);
48584 }
48585 }
48586 return resultobj;
48587 fail:
48588 return NULL;
48589 }
48590
48591
48592 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48593 PyObject *obj;
48594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48595 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48596 return SWIG_Py_Void();
48597 }
48598
48599 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48600 return SWIG_Python_InitShadowInstance(args);
48601 }
48602
48603 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48604 PyObject *resultobj = 0;
48605 wxStdDialogButtonSizer *result = 0 ;
48606
48607 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48608 {
48609 PyThreadState* __tstate = wxPyBeginAllowThreads();
48610 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48611 wxPyEndAllowThreads(__tstate);
48612 if (PyErr_Occurred()) SWIG_fail;
48613 }
48614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48615 return resultobj;
48616 fail:
48617 return NULL;
48618 }
48619
48620
48621 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48622 PyObject *resultobj = 0;
48623 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48624 wxButton *arg2 = (wxButton *) 0 ;
48625 void *argp1 = 0 ;
48626 int res1 = 0 ;
48627 void *argp2 = 0 ;
48628 int res2 = 0 ;
48629 PyObject * obj0 = 0 ;
48630 PyObject * obj1 = 0 ;
48631 char * kwnames[] = {
48632 (char *) "self",(char *) "button", NULL
48633 };
48634
48635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48637 if (!SWIG_IsOK(res1)) {
48638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48639 }
48640 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48642 if (!SWIG_IsOK(res2)) {
48643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48644 }
48645 arg2 = reinterpret_cast< wxButton * >(argp2);
48646 {
48647 PyThreadState* __tstate = wxPyBeginAllowThreads();
48648 (arg1)->AddButton(arg2);
48649 wxPyEndAllowThreads(__tstate);
48650 if (PyErr_Occurred()) SWIG_fail;
48651 }
48652 resultobj = SWIG_Py_Void();
48653 return resultobj;
48654 fail:
48655 return NULL;
48656 }
48657
48658
48659 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48660 PyObject *resultobj = 0;
48661 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48662 void *argp1 = 0 ;
48663 int res1 = 0 ;
48664 PyObject *swig_obj[1] ;
48665
48666 if (!args) SWIG_fail;
48667 swig_obj[0] = args;
48668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48669 if (!SWIG_IsOK(res1)) {
48670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48671 }
48672 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48673 {
48674 PyThreadState* __tstate = wxPyBeginAllowThreads();
48675 (arg1)->Realize();
48676 wxPyEndAllowThreads(__tstate);
48677 if (PyErr_Occurred()) SWIG_fail;
48678 }
48679 resultobj = SWIG_Py_Void();
48680 return resultobj;
48681 fail:
48682 return NULL;
48683 }
48684
48685
48686 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48687 PyObject *resultobj = 0;
48688 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48689 wxButton *arg2 = (wxButton *) 0 ;
48690 void *argp1 = 0 ;
48691 int res1 = 0 ;
48692 void *argp2 = 0 ;
48693 int res2 = 0 ;
48694 PyObject * obj0 = 0 ;
48695 PyObject * obj1 = 0 ;
48696 char * kwnames[] = {
48697 (char *) "self",(char *) "button", NULL
48698 };
48699
48700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48702 if (!SWIG_IsOK(res1)) {
48703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48704 }
48705 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48706 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48707 if (!SWIG_IsOK(res2)) {
48708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48709 }
48710 arg2 = reinterpret_cast< wxButton * >(argp2);
48711 {
48712 PyThreadState* __tstate = wxPyBeginAllowThreads();
48713 (arg1)->SetAffirmativeButton(arg2);
48714 wxPyEndAllowThreads(__tstate);
48715 if (PyErr_Occurred()) SWIG_fail;
48716 }
48717 resultobj = SWIG_Py_Void();
48718 return resultobj;
48719 fail:
48720 return NULL;
48721 }
48722
48723
48724 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48725 PyObject *resultobj = 0;
48726 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48727 wxButton *arg2 = (wxButton *) 0 ;
48728 void *argp1 = 0 ;
48729 int res1 = 0 ;
48730 void *argp2 = 0 ;
48731 int res2 = 0 ;
48732 PyObject * obj0 = 0 ;
48733 PyObject * obj1 = 0 ;
48734 char * kwnames[] = {
48735 (char *) "self",(char *) "button", NULL
48736 };
48737
48738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48740 if (!SWIG_IsOK(res1)) {
48741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48742 }
48743 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48745 if (!SWIG_IsOK(res2)) {
48746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48747 }
48748 arg2 = reinterpret_cast< wxButton * >(argp2);
48749 {
48750 PyThreadState* __tstate = wxPyBeginAllowThreads();
48751 (arg1)->SetNegativeButton(arg2);
48752 wxPyEndAllowThreads(__tstate);
48753 if (PyErr_Occurred()) SWIG_fail;
48754 }
48755 resultobj = SWIG_Py_Void();
48756 return resultobj;
48757 fail:
48758 return NULL;
48759 }
48760
48761
48762 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48763 PyObject *resultobj = 0;
48764 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48765 wxButton *arg2 = (wxButton *) 0 ;
48766 void *argp1 = 0 ;
48767 int res1 = 0 ;
48768 void *argp2 = 0 ;
48769 int res2 = 0 ;
48770 PyObject * obj0 = 0 ;
48771 PyObject * obj1 = 0 ;
48772 char * kwnames[] = {
48773 (char *) "self",(char *) "button", NULL
48774 };
48775
48776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48778 if (!SWIG_IsOK(res1)) {
48779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48780 }
48781 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48782 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48783 if (!SWIG_IsOK(res2)) {
48784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48785 }
48786 arg2 = reinterpret_cast< wxButton * >(argp2);
48787 {
48788 PyThreadState* __tstate = wxPyBeginAllowThreads();
48789 (arg1)->SetCancelButton(arg2);
48790 wxPyEndAllowThreads(__tstate);
48791 if (PyErr_Occurred()) SWIG_fail;
48792 }
48793 resultobj = SWIG_Py_Void();
48794 return resultobj;
48795 fail:
48796 return NULL;
48797 }
48798
48799
48800 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48801 PyObject *resultobj = 0;
48802 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48803 wxButton *result = 0 ;
48804 void *argp1 = 0 ;
48805 int res1 = 0 ;
48806 PyObject *swig_obj[1] ;
48807
48808 if (!args) SWIG_fail;
48809 swig_obj[0] = args;
48810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48811 if (!SWIG_IsOK(res1)) {
48812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48813 }
48814 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48815 {
48816 PyThreadState* __tstate = wxPyBeginAllowThreads();
48817 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48818 wxPyEndAllowThreads(__tstate);
48819 if (PyErr_Occurred()) SWIG_fail;
48820 }
48821 {
48822 resultobj = wxPyMake_wxObject(result, (bool)0);
48823 }
48824 return resultobj;
48825 fail:
48826 return NULL;
48827 }
48828
48829
48830 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48831 PyObject *resultobj = 0;
48832 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48833 wxButton *result = 0 ;
48834 void *argp1 = 0 ;
48835 int res1 = 0 ;
48836 PyObject *swig_obj[1] ;
48837
48838 if (!args) SWIG_fail;
48839 swig_obj[0] = args;
48840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48841 if (!SWIG_IsOK(res1)) {
48842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48843 }
48844 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48845 {
48846 PyThreadState* __tstate = wxPyBeginAllowThreads();
48847 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48848 wxPyEndAllowThreads(__tstate);
48849 if (PyErr_Occurred()) SWIG_fail;
48850 }
48851 {
48852 resultobj = wxPyMake_wxObject(result, (bool)0);
48853 }
48854 return resultobj;
48855 fail:
48856 return NULL;
48857 }
48858
48859
48860 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48861 PyObject *resultobj = 0;
48862 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48863 wxButton *result = 0 ;
48864 void *argp1 = 0 ;
48865 int res1 = 0 ;
48866 PyObject *swig_obj[1] ;
48867
48868 if (!args) SWIG_fail;
48869 swig_obj[0] = args;
48870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48871 if (!SWIG_IsOK(res1)) {
48872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48873 }
48874 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48875 {
48876 PyThreadState* __tstate = wxPyBeginAllowThreads();
48877 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48878 wxPyEndAllowThreads(__tstate);
48879 if (PyErr_Occurred()) SWIG_fail;
48880 }
48881 {
48882 resultobj = wxPyMake_wxObject(result, (bool)0);
48883 }
48884 return resultobj;
48885 fail:
48886 return NULL;
48887 }
48888
48889
48890 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48891 PyObject *resultobj = 0;
48892 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48893 wxButton *result = 0 ;
48894 void *argp1 = 0 ;
48895 int res1 = 0 ;
48896 PyObject *swig_obj[1] ;
48897
48898 if (!args) SWIG_fail;
48899 swig_obj[0] = args;
48900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48901 if (!SWIG_IsOK(res1)) {
48902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48903 }
48904 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48905 {
48906 PyThreadState* __tstate = wxPyBeginAllowThreads();
48907 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48908 wxPyEndAllowThreads(__tstate);
48909 if (PyErr_Occurred()) SWIG_fail;
48910 }
48911 {
48912 resultobj = wxPyMake_wxObject(result, (bool)0);
48913 }
48914 return resultobj;
48915 fail:
48916 return NULL;
48917 }
48918
48919
48920 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48921 PyObject *resultobj = 0;
48922 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48923 wxButton *result = 0 ;
48924 void *argp1 = 0 ;
48925 int res1 = 0 ;
48926 PyObject *swig_obj[1] ;
48927
48928 if (!args) SWIG_fail;
48929 swig_obj[0] = args;
48930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48931 if (!SWIG_IsOK(res1)) {
48932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48933 }
48934 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48935 {
48936 PyThreadState* __tstate = wxPyBeginAllowThreads();
48937 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48938 wxPyEndAllowThreads(__tstate);
48939 if (PyErr_Occurred()) SWIG_fail;
48940 }
48941 {
48942 resultobj = wxPyMake_wxObject(result, (bool)0);
48943 }
48944 return resultobj;
48945 fail:
48946 return NULL;
48947 }
48948
48949
48950 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48951 PyObject *obj;
48952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48953 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48954 return SWIG_Py_Void();
48955 }
48956
48957 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48958 return SWIG_Python_InitShadowInstance(args);
48959 }
48960
48961 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48962 PyObject *resultobj = 0;
48963 int arg1 = (int) 0 ;
48964 int arg2 = (int) 0 ;
48965 wxGBPosition *result = 0 ;
48966 int val1 ;
48967 int ecode1 = 0 ;
48968 int val2 ;
48969 int ecode2 = 0 ;
48970 PyObject * obj0 = 0 ;
48971 PyObject * obj1 = 0 ;
48972 char * kwnames[] = {
48973 (char *) "row",(char *) "col", NULL
48974 };
48975
48976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48977 if (obj0) {
48978 ecode1 = SWIG_AsVal_int(obj0, &val1);
48979 if (!SWIG_IsOK(ecode1)) {
48980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48981 }
48982 arg1 = static_cast< int >(val1);
48983 }
48984 if (obj1) {
48985 ecode2 = SWIG_AsVal_int(obj1, &val2);
48986 if (!SWIG_IsOK(ecode2)) {
48987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48988 }
48989 arg2 = static_cast< int >(val2);
48990 }
48991 {
48992 PyThreadState* __tstate = wxPyBeginAllowThreads();
48993 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48994 wxPyEndAllowThreads(__tstate);
48995 if (PyErr_Occurred()) SWIG_fail;
48996 }
48997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48998 return resultobj;
48999 fail:
49000 return NULL;
49001 }
49002
49003
49004 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49005 PyObject *resultobj = 0;
49006 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49007 void *argp1 = 0 ;
49008 int res1 = 0 ;
49009 PyObject *swig_obj[1] ;
49010
49011 if (!args) SWIG_fail;
49012 swig_obj[0] = args;
49013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49014 if (!SWIG_IsOK(res1)) {
49015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49016 }
49017 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49018 {
49019 PyThreadState* __tstate = wxPyBeginAllowThreads();
49020 delete arg1;
49021
49022 wxPyEndAllowThreads(__tstate);
49023 if (PyErr_Occurred()) SWIG_fail;
49024 }
49025 resultobj = SWIG_Py_Void();
49026 return resultobj;
49027 fail:
49028 return NULL;
49029 }
49030
49031
49032 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49033 PyObject *resultobj = 0;
49034 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49035 int result;
49036 void *argp1 = 0 ;
49037 int res1 = 0 ;
49038 PyObject *swig_obj[1] ;
49039
49040 if (!args) SWIG_fail;
49041 swig_obj[0] = args;
49042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49043 if (!SWIG_IsOK(res1)) {
49044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49045 }
49046 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49047 {
49048 PyThreadState* __tstate = wxPyBeginAllowThreads();
49049 result = (int)((wxGBPosition const *)arg1)->GetRow();
49050 wxPyEndAllowThreads(__tstate);
49051 if (PyErr_Occurred()) SWIG_fail;
49052 }
49053 resultobj = SWIG_From_int(static_cast< int >(result));
49054 return resultobj;
49055 fail:
49056 return NULL;
49057 }
49058
49059
49060 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49061 PyObject *resultobj = 0;
49062 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49063 int result;
49064 void *argp1 = 0 ;
49065 int res1 = 0 ;
49066 PyObject *swig_obj[1] ;
49067
49068 if (!args) SWIG_fail;
49069 swig_obj[0] = args;
49070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49071 if (!SWIG_IsOK(res1)) {
49072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49073 }
49074 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49075 {
49076 PyThreadState* __tstate = wxPyBeginAllowThreads();
49077 result = (int)((wxGBPosition const *)arg1)->GetCol();
49078 wxPyEndAllowThreads(__tstate);
49079 if (PyErr_Occurred()) SWIG_fail;
49080 }
49081 resultobj = SWIG_From_int(static_cast< int >(result));
49082 return resultobj;
49083 fail:
49084 return NULL;
49085 }
49086
49087
49088 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49089 PyObject *resultobj = 0;
49090 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49091 int arg2 ;
49092 void *argp1 = 0 ;
49093 int res1 = 0 ;
49094 int val2 ;
49095 int ecode2 = 0 ;
49096 PyObject * obj0 = 0 ;
49097 PyObject * obj1 = 0 ;
49098 char * kwnames[] = {
49099 (char *) "self",(char *) "row", NULL
49100 };
49101
49102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49104 if (!SWIG_IsOK(res1)) {
49105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49106 }
49107 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49108 ecode2 = SWIG_AsVal_int(obj1, &val2);
49109 if (!SWIG_IsOK(ecode2)) {
49110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49111 }
49112 arg2 = static_cast< int >(val2);
49113 {
49114 PyThreadState* __tstate = wxPyBeginAllowThreads();
49115 (arg1)->SetRow(arg2);
49116 wxPyEndAllowThreads(__tstate);
49117 if (PyErr_Occurred()) SWIG_fail;
49118 }
49119 resultobj = SWIG_Py_Void();
49120 return resultobj;
49121 fail:
49122 return NULL;
49123 }
49124
49125
49126 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49127 PyObject *resultobj = 0;
49128 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49129 int arg2 ;
49130 void *argp1 = 0 ;
49131 int res1 = 0 ;
49132 int val2 ;
49133 int ecode2 = 0 ;
49134 PyObject * obj0 = 0 ;
49135 PyObject * obj1 = 0 ;
49136 char * kwnames[] = {
49137 (char *) "self",(char *) "col", NULL
49138 };
49139
49140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49142 if (!SWIG_IsOK(res1)) {
49143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49144 }
49145 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49146 ecode2 = SWIG_AsVal_int(obj1, &val2);
49147 if (!SWIG_IsOK(ecode2)) {
49148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49149 }
49150 arg2 = static_cast< int >(val2);
49151 {
49152 PyThreadState* __tstate = wxPyBeginAllowThreads();
49153 (arg1)->SetCol(arg2);
49154 wxPyEndAllowThreads(__tstate);
49155 if (PyErr_Occurred()) SWIG_fail;
49156 }
49157 resultobj = SWIG_Py_Void();
49158 return resultobj;
49159 fail:
49160 return NULL;
49161 }
49162
49163
49164 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49165 PyObject *resultobj = 0;
49166 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49167 PyObject *arg2 = (PyObject *) 0 ;
49168 bool result;
49169 void *argp1 = 0 ;
49170 int res1 = 0 ;
49171 PyObject * obj0 = 0 ;
49172 PyObject * obj1 = 0 ;
49173 char * kwnames[] = {
49174 (char *) "self",(char *) "other", NULL
49175 };
49176
49177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49179 if (!SWIG_IsOK(res1)) {
49180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49181 }
49182 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49183 arg2 = obj1;
49184 {
49185 result = (bool)wxGBPosition___eq__(arg1,arg2);
49186 if (PyErr_Occurred()) SWIG_fail;
49187 }
49188 {
49189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49190 }
49191 return resultobj;
49192 fail:
49193 return NULL;
49194 }
49195
49196
49197 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49198 PyObject *resultobj = 0;
49199 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49200 PyObject *arg2 = (PyObject *) 0 ;
49201 bool result;
49202 void *argp1 = 0 ;
49203 int res1 = 0 ;
49204 PyObject * obj0 = 0 ;
49205 PyObject * obj1 = 0 ;
49206 char * kwnames[] = {
49207 (char *) "self",(char *) "other", NULL
49208 };
49209
49210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49212 if (!SWIG_IsOK(res1)) {
49213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49214 }
49215 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49216 arg2 = obj1;
49217 {
49218 result = (bool)wxGBPosition___ne__(arg1,arg2);
49219 if (PyErr_Occurred()) SWIG_fail;
49220 }
49221 {
49222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49223 }
49224 return resultobj;
49225 fail:
49226 return NULL;
49227 }
49228
49229
49230 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49231 PyObject *resultobj = 0;
49232 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49233 int arg2 = (int) 0 ;
49234 int arg3 = (int) 0 ;
49235 void *argp1 = 0 ;
49236 int res1 = 0 ;
49237 int val2 ;
49238 int ecode2 = 0 ;
49239 int val3 ;
49240 int ecode3 = 0 ;
49241 PyObject * obj0 = 0 ;
49242 PyObject * obj1 = 0 ;
49243 PyObject * obj2 = 0 ;
49244 char * kwnames[] = {
49245 (char *) "self",(char *) "row",(char *) "col", NULL
49246 };
49247
49248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49250 if (!SWIG_IsOK(res1)) {
49251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49252 }
49253 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49254 if (obj1) {
49255 ecode2 = SWIG_AsVal_int(obj1, &val2);
49256 if (!SWIG_IsOK(ecode2)) {
49257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49258 }
49259 arg2 = static_cast< int >(val2);
49260 }
49261 if (obj2) {
49262 ecode3 = SWIG_AsVal_int(obj2, &val3);
49263 if (!SWIG_IsOK(ecode3)) {
49264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49265 }
49266 arg3 = static_cast< int >(val3);
49267 }
49268 {
49269 PyThreadState* __tstate = wxPyBeginAllowThreads();
49270 wxGBPosition_Set(arg1,arg2,arg3);
49271 wxPyEndAllowThreads(__tstate);
49272 if (PyErr_Occurred()) SWIG_fail;
49273 }
49274 resultobj = SWIG_Py_Void();
49275 return resultobj;
49276 fail:
49277 return NULL;
49278 }
49279
49280
49281 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49282 PyObject *resultobj = 0;
49283 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49284 PyObject *result = 0 ;
49285 void *argp1 = 0 ;
49286 int res1 = 0 ;
49287 PyObject *swig_obj[1] ;
49288
49289 if (!args) SWIG_fail;
49290 swig_obj[0] = args;
49291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49292 if (!SWIG_IsOK(res1)) {
49293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49294 }
49295 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49296 {
49297 PyThreadState* __tstate = wxPyBeginAllowThreads();
49298 result = (PyObject *)wxGBPosition_Get(arg1);
49299 wxPyEndAllowThreads(__tstate);
49300 if (PyErr_Occurred()) SWIG_fail;
49301 }
49302 resultobj = result;
49303 return resultobj;
49304 fail:
49305 return NULL;
49306 }
49307
49308
49309 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49310 PyObject *obj;
49311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49312 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49313 return SWIG_Py_Void();
49314 }
49315
49316 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49317 return SWIG_Python_InitShadowInstance(args);
49318 }
49319
49320 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49321 PyObject *resultobj = 0;
49322 int arg1 = (int) 1 ;
49323 int arg2 = (int) 1 ;
49324 wxGBSpan *result = 0 ;
49325 int val1 ;
49326 int ecode1 = 0 ;
49327 int val2 ;
49328 int ecode2 = 0 ;
49329 PyObject * obj0 = 0 ;
49330 PyObject * obj1 = 0 ;
49331 char * kwnames[] = {
49332 (char *) "rowspan",(char *) "colspan", NULL
49333 };
49334
49335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49336 if (obj0) {
49337 ecode1 = SWIG_AsVal_int(obj0, &val1);
49338 if (!SWIG_IsOK(ecode1)) {
49339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49340 }
49341 arg1 = static_cast< int >(val1);
49342 }
49343 if (obj1) {
49344 ecode2 = SWIG_AsVal_int(obj1, &val2);
49345 if (!SWIG_IsOK(ecode2)) {
49346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49347 }
49348 arg2 = static_cast< int >(val2);
49349 }
49350 {
49351 PyThreadState* __tstate = wxPyBeginAllowThreads();
49352 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49353 wxPyEndAllowThreads(__tstate);
49354 if (PyErr_Occurred()) SWIG_fail;
49355 }
49356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49357 return resultobj;
49358 fail:
49359 return NULL;
49360 }
49361
49362
49363 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49364 PyObject *resultobj = 0;
49365 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49366 void *argp1 = 0 ;
49367 int res1 = 0 ;
49368 PyObject *swig_obj[1] ;
49369
49370 if (!args) SWIG_fail;
49371 swig_obj[0] = args;
49372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49373 if (!SWIG_IsOK(res1)) {
49374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49375 }
49376 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49377 {
49378 PyThreadState* __tstate = wxPyBeginAllowThreads();
49379 delete arg1;
49380
49381 wxPyEndAllowThreads(__tstate);
49382 if (PyErr_Occurred()) SWIG_fail;
49383 }
49384 resultobj = SWIG_Py_Void();
49385 return resultobj;
49386 fail:
49387 return NULL;
49388 }
49389
49390
49391 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49392 PyObject *resultobj = 0;
49393 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49394 int result;
49395 void *argp1 = 0 ;
49396 int res1 = 0 ;
49397 PyObject *swig_obj[1] ;
49398
49399 if (!args) SWIG_fail;
49400 swig_obj[0] = args;
49401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49402 if (!SWIG_IsOK(res1)) {
49403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49404 }
49405 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49406 {
49407 PyThreadState* __tstate = wxPyBeginAllowThreads();
49408 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49409 wxPyEndAllowThreads(__tstate);
49410 if (PyErr_Occurred()) SWIG_fail;
49411 }
49412 resultobj = SWIG_From_int(static_cast< int >(result));
49413 return resultobj;
49414 fail:
49415 return NULL;
49416 }
49417
49418
49419 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49420 PyObject *resultobj = 0;
49421 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49422 int result;
49423 void *argp1 = 0 ;
49424 int res1 = 0 ;
49425 PyObject *swig_obj[1] ;
49426
49427 if (!args) SWIG_fail;
49428 swig_obj[0] = args;
49429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49430 if (!SWIG_IsOK(res1)) {
49431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49432 }
49433 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49434 {
49435 PyThreadState* __tstate = wxPyBeginAllowThreads();
49436 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49437 wxPyEndAllowThreads(__tstate);
49438 if (PyErr_Occurred()) SWIG_fail;
49439 }
49440 resultobj = SWIG_From_int(static_cast< int >(result));
49441 return resultobj;
49442 fail:
49443 return NULL;
49444 }
49445
49446
49447 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49448 PyObject *resultobj = 0;
49449 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49450 int arg2 ;
49451 void *argp1 = 0 ;
49452 int res1 = 0 ;
49453 int val2 ;
49454 int ecode2 = 0 ;
49455 PyObject * obj0 = 0 ;
49456 PyObject * obj1 = 0 ;
49457 char * kwnames[] = {
49458 (char *) "self",(char *) "rowspan", NULL
49459 };
49460
49461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49463 if (!SWIG_IsOK(res1)) {
49464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49465 }
49466 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49467 ecode2 = SWIG_AsVal_int(obj1, &val2);
49468 if (!SWIG_IsOK(ecode2)) {
49469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49470 }
49471 arg2 = static_cast< int >(val2);
49472 {
49473 PyThreadState* __tstate = wxPyBeginAllowThreads();
49474 (arg1)->SetRowspan(arg2);
49475 wxPyEndAllowThreads(__tstate);
49476 if (PyErr_Occurred()) SWIG_fail;
49477 }
49478 resultobj = SWIG_Py_Void();
49479 return resultobj;
49480 fail:
49481 return NULL;
49482 }
49483
49484
49485 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49486 PyObject *resultobj = 0;
49487 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49488 int arg2 ;
49489 void *argp1 = 0 ;
49490 int res1 = 0 ;
49491 int val2 ;
49492 int ecode2 = 0 ;
49493 PyObject * obj0 = 0 ;
49494 PyObject * obj1 = 0 ;
49495 char * kwnames[] = {
49496 (char *) "self",(char *) "colspan", NULL
49497 };
49498
49499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49501 if (!SWIG_IsOK(res1)) {
49502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49503 }
49504 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49505 ecode2 = SWIG_AsVal_int(obj1, &val2);
49506 if (!SWIG_IsOK(ecode2)) {
49507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49508 }
49509 arg2 = static_cast< int >(val2);
49510 {
49511 PyThreadState* __tstate = wxPyBeginAllowThreads();
49512 (arg1)->SetColspan(arg2);
49513 wxPyEndAllowThreads(__tstate);
49514 if (PyErr_Occurred()) SWIG_fail;
49515 }
49516 resultobj = SWIG_Py_Void();
49517 return resultobj;
49518 fail:
49519 return NULL;
49520 }
49521
49522
49523 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49524 PyObject *resultobj = 0;
49525 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49526 PyObject *arg2 = (PyObject *) 0 ;
49527 bool result;
49528 void *argp1 = 0 ;
49529 int res1 = 0 ;
49530 PyObject * obj0 = 0 ;
49531 PyObject * obj1 = 0 ;
49532 char * kwnames[] = {
49533 (char *) "self",(char *) "other", NULL
49534 };
49535
49536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49538 if (!SWIG_IsOK(res1)) {
49539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49540 }
49541 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49542 arg2 = obj1;
49543 {
49544 result = (bool)wxGBSpan___eq__(arg1,arg2);
49545 if (PyErr_Occurred()) SWIG_fail;
49546 }
49547 {
49548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49549 }
49550 return resultobj;
49551 fail:
49552 return NULL;
49553 }
49554
49555
49556 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49557 PyObject *resultobj = 0;
49558 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49559 PyObject *arg2 = (PyObject *) 0 ;
49560 bool result;
49561 void *argp1 = 0 ;
49562 int res1 = 0 ;
49563 PyObject * obj0 = 0 ;
49564 PyObject * obj1 = 0 ;
49565 char * kwnames[] = {
49566 (char *) "self",(char *) "other", NULL
49567 };
49568
49569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49571 if (!SWIG_IsOK(res1)) {
49572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49573 }
49574 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49575 arg2 = obj1;
49576 {
49577 result = (bool)wxGBSpan___ne__(arg1,arg2);
49578 if (PyErr_Occurred()) SWIG_fail;
49579 }
49580 {
49581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49582 }
49583 return resultobj;
49584 fail:
49585 return NULL;
49586 }
49587
49588
49589 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49590 PyObject *resultobj = 0;
49591 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49592 int arg2 = (int) 1 ;
49593 int arg3 = (int) 1 ;
49594 void *argp1 = 0 ;
49595 int res1 = 0 ;
49596 int val2 ;
49597 int ecode2 = 0 ;
49598 int val3 ;
49599 int ecode3 = 0 ;
49600 PyObject * obj0 = 0 ;
49601 PyObject * obj1 = 0 ;
49602 PyObject * obj2 = 0 ;
49603 char * kwnames[] = {
49604 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49605 };
49606
49607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49609 if (!SWIG_IsOK(res1)) {
49610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49611 }
49612 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49613 if (obj1) {
49614 ecode2 = SWIG_AsVal_int(obj1, &val2);
49615 if (!SWIG_IsOK(ecode2)) {
49616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49617 }
49618 arg2 = static_cast< int >(val2);
49619 }
49620 if (obj2) {
49621 ecode3 = SWIG_AsVal_int(obj2, &val3);
49622 if (!SWIG_IsOK(ecode3)) {
49623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49624 }
49625 arg3 = static_cast< int >(val3);
49626 }
49627 {
49628 PyThreadState* __tstate = wxPyBeginAllowThreads();
49629 wxGBSpan_Set(arg1,arg2,arg3);
49630 wxPyEndAllowThreads(__tstate);
49631 if (PyErr_Occurred()) SWIG_fail;
49632 }
49633 resultobj = SWIG_Py_Void();
49634 return resultobj;
49635 fail:
49636 return NULL;
49637 }
49638
49639
49640 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49641 PyObject *resultobj = 0;
49642 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49643 PyObject *result = 0 ;
49644 void *argp1 = 0 ;
49645 int res1 = 0 ;
49646 PyObject *swig_obj[1] ;
49647
49648 if (!args) SWIG_fail;
49649 swig_obj[0] = args;
49650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49651 if (!SWIG_IsOK(res1)) {
49652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49653 }
49654 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49655 {
49656 PyThreadState* __tstate = wxPyBeginAllowThreads();
49657 result = (PyObject *)wxGBSpan_Get(arg1);
49658 wxPyEndAllowThreads(__tstate);
49659 if (PyErr_Occurred()) SWIG_fail;
49660 }
49661 resultobj = result;
49662 return resultobj;
49663 fail:
49664 return NULL;
49665 }
49666
49667
49668 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49669 PyObject *obj;
49670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49671 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49672 return SWIG_Py_Void();
49673 }
49674
49675 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49676 return SWIG_Python_InitShadowInstance(args);
49677 }
49678
49679 SWIGINTERN int DefaultSpan_set(PyObject *) {
49680 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49681 return 1;
49682 }
49683
49684
49685 SWIGINTERN PyObject *DefaultSpan_get(void) {
49686 PyObject *pyobj = 0;
49687
49688 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49689 return pyobj;
49690 }
49691
49692
49693 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49694 PyObject *resultobj = 0;
49695 wxGBSizerItem *result = 0 ;
49696
49697 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49698 {
49699 PyThreadState* __tstate = wxPyBeginAllowThreads();
49700 result = (wxGBSizerItem *)new wxGBSizerItem();
49701 wxPyEndAllowThreads(__tstate);
49702 if (PyErr_Occurred()) SWIG_fail;
49703 }
49704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49705 return resultobj;
49706 fail:
49707 return NULL;
49708 }
49709
49710
49711 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49712 PyObject *resultobj = 0;
49713 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49714 void *argp1 = 0 ;
49715 int res1 = 0 ;
49716 PyObject *swig_obj[1] ;
49717
49718 if (!args) SWIG_fail;
49719 swig_obj[0] = args;
49720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49721 if (!SWIG_IsOK(res1)) {
49722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49723 }
49724 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49725 {
49726 PyThreadState* __tstate = wxPyBeginAllowThreads();
49727 delete arg1;
49728
49729 wxPyEndAllowThreads(__tstate);
49730 if (PyErr_Occurred()) SWIG_fail;
49731 }
49732 resultobj = SWIG_Py_Void();
49733 return resultobj;
49734 fail:
49735 return NULL;
49736 }
49737
49738
49739 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49740 PyObject *resultobj = 0;
49741 wxWindow *arg1 = (wxWindow *) 0 ;
49742 wxGBPosition *arg2 = 0 ;
49743 wxGBSpan *arg3 = 0 ;
49744 int arg4 ;
49745 int arg5 ;
49746 PyObject *arg6 = (PyObject *) NULL ;
49747 wxGBSizerItem *result = 0 ;
49748 void *argp1 = 0 ;
49749 int res1 = 0 ;
49750 wxGBPosition temp2 ;
49751 wxGBSpan temp3 ;
49752 int val4 ;
49753 int ecode4 = 0 ;
49754 int val5 ;
49755 int ecode5 = 0 ;
49756 PyObject * obj0 = 0 ;
49757 PyObject * obj1 = 0 ;
49758 PyObject * obj2 = 0 ;
49759 PyObject * obj3 = 0 ;
49760 PyObject * obj4 = 0 ;
49761 PyObject * obj5 = 0 ;
49762 char * kwnames[] = {
49763 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49764 };
49765
49766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49768 if (!SWIG_IsOK(res1)) {
49769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49770 }
49771 arg1 = reinterpret_cast< wxWindow * >(argp1);
49772 {
49773 arg2 = &temp2;
49774 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49775 }
49776 {
49777 arg3 = &temp3;
49778 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49779 }
49780 ecode4 = SWIG_AsVal_int(obj3, &val4);
49781 if (!SWIG_IsOK(ecode4)) {
49782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49783 }
49784 arg4 = static_cast< int >(val4);
49785 ecode5 = SWIG_AsVal_int(obj4, &val5);
49786 if (!SWIG_IsOK(ecode5)) {
49787 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49788 }
49789 arg5 = static_cast< int >(val5);
49790 if (obj5) {
49791 arg6 = obj5;
49792 }
49793 {
49794 PyThreadState* __tstate = wxPyBeginAllowThreads();
49795 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49796 wxPyEndAllowThreads(__tstate);
49797 if (PyErr_Occurred()) SWIG_fail;
49798 }
49799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49800 return resultobj;
49801 fail:
49802 return NULL;
49803 }
49804
49805
49806 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49807 PyObject *resultobj = 0;
49808 wxSizer *arg1 = (wxSizer *) 0 ;
49809 wxGBPosition *arg2 = 0 ;
49810 wxGBSpan *arg3 = 0 ;
49811 int arg4 ;
49812 int arg5 ;
49813 PyObject *arg6 = (PyObject *) NULL ;
49814 wxGBSizerItem *result = 0 ;
49815 int res1 = 0 ;
49816 wxGBPosition temp2 ;
49817 wxGBSpan temp3 ;
49818 int val4 ;
49819 int ecode4 = 0 ;
49820 int val5 ;
49821 int ecode5 = 0 ;
49822 PyObject * obj0 = 0 ;
49823 PyObject * obj1 = 0 ;
49824 PyObject * obj2 = 0 ;
49825 PyObject * obj3 = 0 ;
49826 PyObject * obj4 = 0 ;
49827 PyObject * obj5 = 0 ;
49828 char * kwnames[] = {
49829 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49830 };
49831
49832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49833 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49834 if (!SWIG_IsOK(res1)) {
49835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49836 }
49837 {
49838 arg2 = &temp2;
49839 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49840 }
49841 {
49842 arg3 = &temp3;
49843 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49844 }
49845 ecode4 = SWIG_AsVal_int(obj3, &val4);
49846 if (!SWIG_IsOK(ecode4)) {
49847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49848 }
49849 arg4 = static_cast< int >(val4);
49850 ecode5 = SWIG_AsVal_int(obj4, &val5);
49851 if (!SWIG_IsOK(ecode5)) {
49852 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49853 }
49854 arg5 = static_cast< int >(val5);
49855 if (obj5) {
49856 arg6 = obj5;
49857 }
49858 {
49859 PyThreadState* __tstate = wxPyBeginAllowThreads();
49860 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49861 wxPyEndAllowThreads(__tstate);
49862 if (PyErr_Occurred()) SWIG_fail;
49863 }
49864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49865 return resultobj;
49866 fail:
49867 return NULL;
49868 }
49869
49870
49871 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49872 PyObject *resultobj = 0;
49873 int arg1 ;
49874 int arg2 ;
49875 wxGBPosition *arg3 = 0 ;
49876 wxGBSpan *arg4 = 0 ;
49877 int arg5 ;
49878 int arg6 ;
49879 PyObject *arg7 = (PyObject *) NULL ;
49880 wxGBSizerItem *result = 0 ;
49881 int val1 ;
49882 int ecode1 = 0 ;
49883 int val2 ;
49884 int ecode2 = 0 ;
49885 wxGBPosition temp3 ;
49886 wxGBSpan temp4 ;
49887 int val5 ;
49888 int ecode5 = 0 ;
49889 int val6 ;
49890 int ecode6 = 0 ;
49891 PyObject * obj0 = 0 ;
49892 PyObject * obj1 = 0 ;
49893 PyObject * obj2 = 0 ;
49894 PyObject * obj3 = 0 ;
49895 PyObject * obj4 = 0 ;
49896 PyObject * obj5 = 0 ;
49897 PyObject * obj6 = 0 ;
49898 char * kwnames[] = {
49899 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49900 };
49901
49902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49903 ecode1 = SWIG_AsVal_int(obj0, &val1);
49904 if (!SWIG_IsOK(ecode1)) {
49905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49906 }
49907 arg1 = static_cast< int >(val1);
49908 ecode2 = SWIG_AsVal_int(obj1, &val2);
49909 if (!SWIG_IsOK(ecode2)) {
49910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49911 }
49912 arg2 = static_cast< int >(val2);
49913 {
49914 arg3 = &temp3;
49915 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49916 }
49917 {
49918 arg4 = &temp4;
49919 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49920 }
49921 ecode5 = SWIG_AsVal_int(obj4, &val5);
49922 if (!SWIG_IsOK(ecode5)) {
49923 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49924 }
49925 arg5 = static_cast< int >(val5);
49926 ecode6 = SWIG_AsVal_int(obj5, &val6);
49927 if (!SWIG_IsOK(ecode6)) {
49928 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49929 }
49930 arg6 = static_cast< int >(val6);
49931 if (obj6) {
49932 arg7 = obj6;
49933 }
49934 {
49935 PyThreadState* __tstate = wxPyBeginAllowThreads();
49936 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49937 wxPyEndAllowThreads(__tstate);
49938 if (PyErr_Occurred()) SWIG_fail;
49939 }
49940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49941 return resultobj;
49942 fail:
49943 return NULL;
49944 }
49945
49946
49947 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49948 PyObject *resultobj = 0;
49949 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49950 wxGBPosition result;
49951 void *argp1 = 0 ;
49952 int res1 = 0 ;
49953 PyObject *swig_obj[1] ;
49954
49955 if (!args) SWIG_fail;
49956 swig_obj[0] = args;
49957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49958 if (!SWIG_IsOK(res1)) {
49959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49960 }
49961 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49962 {
49963 PyThreadState* __tstate = wxPyBeginAllowThreads();
49964 result = ((wxGBSizerItem const *)arg1)->GetPos();
49965 wxPyEndAllowThreads(__tstate);
49966 if (PyErr_Occurred()) SWIG_fail;
49967 }
49968 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49969 return resultobj;
49970 fail:
49971 return NULL;
49972 }
49973
49974
49975 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49976 PyObject *resultobj = 0;
49977 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49978 wxGBSpan result;
49979 void *argp1 = 0 ;
49980 int res1 = 0 ;
49981 PyObject *swig_obj[1] ;
49982
49983 if (!args) SWIG_fail;
49984 swig_obj[0] = args;
49985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49986 if (!SWIG_IsOK(res1)) {
49987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49988 }
49989 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49990 {
49991 PyThreadState* __tstate = wxPyBeginAllowThreads();
49992 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49993 wxPyEndAllowThreads(__tstate);
49994 if (PyErr_Occurred()) SWIG_fail;
49995 }
49996 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49997 return resultobj;
49998 fail:
49999 return NULL;
50000 }
50001
50002
50003 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50004 PyObject *resultobj = 0;
50005 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50006 wxGBPosition *arg2 = 0 ;
50007 bool result;
50008 void *argp1 = 0 ;
50009 int res1 = 0 ;
50010 wxGBPosition temp2 ;
50011 PyObject * obj0 = 0 ;
50012 PyObject * obj1 = 0 ;
50013 char * kwnames[] = {
50014 (char *) "self",(char *) "pos", NULL
50015 };
50016
50017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50019 if (!SWIG_IsOK(res1)) {
50020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50021 }
50022 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50023 {
50024 arg2 = &temp2;
50025 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50026 }
50027 {
50028 PyThreadState* __tstate = wxPyBeginAllowThreads();
50029 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50030 wxPyEndAllowThreads(__tstate);
50031 if (PyErr_Occurred()) SWIG_fail;
50032 }
50033 {
50034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50035 }
50036 return resultobj;
50037 fail:
50038 return NULL;
50039 }
50040
50041
50042 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50043 PyObject *resultobj = 0;
50044 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50045 wxGBSpan *arg2 = 0 ;
50046 bool result;
50047 void *argp1 = 0 ;
50048 int res1 = 0 ;
50049 wxGBSpan temp2 ;
50050 PyObject * obj0 = 0 ;
50051 PyObject * obj1 = 0 ;
50052 char * kwnames[] = {
50053 (char *) "self",(char *) "span", NULL
50054 };
50055
50056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50058 if (!SWIG_IsOK(res1)) {
50059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50060 }
50061 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50062 {
50063 arg2 = &temp2;
50064 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50065 }
50066 {
50067 PyThreadState* __tstate = wxPyBeginAllowThreads();
50068 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50069 wxPyEndAllowThreads(__tstate);
50070 if (PyErr_Occurred()) SWIG_fail;
50071 }
50072 {
50073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50074 }
50075 return resultobj;
50076 fail:
50077 return NULL;
50078 }
50079
50080
50081 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50082 PyObject *resultobj = 0;
50083 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50084 wxGBSizerItem *arg2 = 0 ;
50085 bool result;
50086 void *argp1 = 0 ;
50087 int res1 = 0 ;
50088 void *argp2 = 0 ;
50089 int res2 = 0 ;
50090 PyObject * obj0 = 0 ;
50091 PyObject * obj1 = 0 ;
50092 char * kwnames[] = {
50093 (char *) "self",(char *) "other", NULL
50094 };
50095
50096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50098 if (!SWIG_IsOK(res1)) {
50099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50100 }
50101 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50102 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50103 if (!SWIG_IsOK(res2)) {
50104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50105 }
50106 if (!argp2) {
50107 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50108 }
50109 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50110 {
50111 PyThreadState* __tstate = wxPyBeginAllowThreads();
50112 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50113 wxPyEndAllowThreads(__tstate);
50114 if (PyErr_Occurred()) SWIG_fail;
50115 }
50116 {
50117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50118 }
50119 return resultobj;
50120 fail:
50121 return NULL;
50122 }
50123
50124
50125 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50126 PyObject *resultobj = 0;
50127 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50128 wxGBPosition *arg2 = 0 ;
50129 wxGBSpan *arg3 = 0 ;
50130 bool result;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 wxGBPosition temp2 ;
50134 wxGBSpan temp3 ;
50135 PyObject * obj0 = 0 ;
50136 PyObject * obj1 = 0 ;
50137 PyObject * obj2 = 0 ;
50138 char * kwnames[] = {
50139 (char *) "self",(char *) "pos",(char *) "span", NULL
50140 };
50141
50142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50144 if (!SWIG_IsOK(res1)) {
50145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50146 }
50147 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50148 {
50149 arg2 = &temp2;
50150 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50151 }
50152 {
50153 arg3 = &temp3;
50154 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50155 }
50156 {
50157 PyThreadState* __tstate = wxPyBeginAllowThreads();
50158 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50159 wxPyEndAllowThreads(__tstate);
50160 if (PyErr_Occurred()) SWIG_fail;
50161 }
50162 {
50163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50164 }
50165 return resultobj;
50166 fail:
50167 return NULL;
50168 }
50169
50170
50171 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(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_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50184 }
50185 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50186 {
50187 PyThreadState* __tstate = wxPyBeginAllowThreads();
50188 result = wxGBSizerItem_GetEndPos(arg1);
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_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50200 PyObject *resultobj = 0;
50201 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50202 wxGridBagSizer *result = 0 ;
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_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50212 }
50213 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50214 {
50215 PyThreadState* __tstate = wxPyBeginAllowThreads();
50216 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50217 wxPyEndAllowThreads(__tstate);
50218 if (PyErr_Occurred()) SWIG_fail;
50219 }
50220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50221 return resultobj;
50222 fail:
50223 return NULL;
50224 }
50225
50226
50227 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50228 PyObject *resultobj = 0;
50229 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50230 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50231 void *argp1 = 0 ;
50232 int res1 = 0 ;
50233 void *argp2 = 0 ;
50234 int res2 = 0 ;
50235 PyObject * obj0 = 0 ;
50236 PyObject * obj1 = 0 ;
50237 char * kwnames[] = {
50238 (char *) "self",(char *) "sizer", NULL
50239 };
50240
50241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",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_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50245 }
50246 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50248 if (!SWIG_IsOK(res2)) {
50249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50250 }
50251 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50252 {
50253 PyThreadState* __tstate = wxPyBeginAllowThreads();
50254 (arg1)->SetGBSizer(arg2);
50255 wxPyEndAllowThreads(__tstate);
50256 if (PyErr_Occurred()) SWIG_fail;
50257 }
50258 resultobj = SWIG_Py_Void();
50259 return resultobj;
50260 fail:
50261 return NULL;
50262 }
50263
50264
50265 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50266 PyObject *obj;
50267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50268 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50269 return SWIG_Py_Void();
50270 }
50271
50272 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50273 return SWIG_Python_InitShadowInstance(args);
50274 }
50275
50276 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50277 PyObject *resultobj = 0;
50278 int arg1 = (int) 0 ;
50279 int arg2 = (int) 0 ;
50280 wxGridBagSizer *result = 0 ;
50281 int val1 ;
50282 int ecode1 = 0 ;
50283 int val2 ;
50284 int ecode2 = 0 ;
50285 PyObject * obj0 = 0 ;
50286 PyObject * obj1 = 0 ;
50287 char * kwnames[] = {
50288 (char *) "vgap",(char *) "hgap", NULL
50289 };
50290
50291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50292 if (obj0) {
50293 ecode1 = SWIG_AsVal_int(obj0, &val1);
50294 if (!SWIG_IsOK(ecode1)) {
50295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50296 }
50297 arg1 = static_cast< int >(val1);
50298 }
50299 if (obj1) {
50300 ecode2 = SWIG_AsVal_int(obj1, &val2);
50301 if (!SWIG_IsOK(ecode2)) {
50302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50303 }
50304 arg2 = static_cast< int >(val2);
50305 }
50306 {
50307 PyThreadState* __tstate = wxPyBeginAllowThreads();
50308 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50309 wxPyEndAllowThreads(__tstate);
50310 if (PyErr_Occurred()) SWIG_fail;
50311 }
50312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50313 return resultobj;
50314 fail:
50315 return NULL;
50316 }
50317
50318
50319 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50320 PyObject *resultobj = 0;
50321 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50322 PyObject *arg2 = (PyObject *) 0 ;
50323 wxGBPosition *arg3 = 0 ;
50324 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50325 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50326 int arg5 = (int) 0 ;
50327 int arg6 = (int) 0 ;
50328 PyObject *arg7 = (PyObject *) NULL ;
50329 wxGBSizerItem *result = 0 ;
50330 void *argp1 = 0 ;
50331 int res1 = 0 ;
50332 wxGBPosition temp3 ;
50333 wxGBSpan temp4 ;
50334 int val5 ;
50335 int ecode5 = 0 ;
50336 int val6 ;
50337 int ecode6 = 0 ;
50338 PyObject * obj0 = 0 ;
50339 PyObject * obj1 = 0 ;
50340 PyObject * obj2 = 0 ;
50341 PyObject * obj3 = 0 ;
50342 PyObject * obj4 = 0 ;
50343 PyObject * obj5 = 0 ;
50344 PyObject * obj6 = 0 ;
50345 char * kwnames[] = {
50346 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50347 };
50348
50349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50351 if (!SWIG_IsOK(res1)) {
50352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50353 }
50354 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50355 arg2 = obj1;
50356 {
50357 arg3 = &temp3;
50358 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50359 }
50360 if (obj3) {
50361 {
50362 arg4 = &temp4;
50363 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50364 }
50365 }
50366 if (obj4) {
50367 ecode5 = SWIG_AsVal_int(obj4, &val5);
50368 if (!SWIG_IsOK(ecode5)) {
50369 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50370 }
50371 arg5 = static_cast< int >(val5);
50372 }
50373 if (obj5) {
50374 ecode6 = SWIG_AsVal_int(obj5, &val6);
50375 if (!SWIG_IsOK(ecode6)) {
50376 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50377 }
50378 arg6 = static_cast< int >(val6);
50379 }
50380 if (obj6) {
50381 arg7 = obj6;
50382 }
50383 {
50384 PyThreadState* __tstate = wxPyBeginAllowThreads();
50385 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50386 wxPyEndAllowThreads(__tstate);
50387 if (PyErr_Occurred()) SWIG_fail;
50388 }
50389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50390 return resultobj;
50391 fail:
50392 return NULL;
50393 }
50394
50395
50396 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50397 PyObject *resultobj = 0;
50398 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50399 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50400 wxGBSizerItem *result = 0 ;
50401 void *argp1 = 0 ;
50402 int res1 = 0 ;
50403 int res2 = 0 ;
50404 PyObject * obj0 = 0 ;
50405 PyObject * obj1 = 0 ;
50406 char * kwnames[] = {
50407 (char *) "self",(char *) "item", NULL
50408 };
50409
50410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50412 if (!SWIG_IsOK(res1)) {
50413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50414 }
50415 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50416 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50417 if (!SWIG_IsOK(res2)) {
50418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50419 }
50420 {
50421 PyThreadState* __tstate = wxPyBeginAllowThreads();
50422 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50423 wxPyEndAllowThreads(__tstate);
50424 if (PyErr_Occurred()) SWIG_fail;
50425 }
50426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50427 return resultobj;
50428 fail:
50429 return NULL;
50430 }
50431
50432
50433 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50434 PyObject *resultobj = 0;
50435 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50436 int arg2 ;
50437 int arg3 ;
50438 wxSize result;
50439 void *argp1 = 0 ;
50440 int res1 = 0 ;
50441 int val2 ;
50442 int ecode2 = 0 ;
50443 int val3 ;
50444 int ecode3 = 0 ;
50445 PyObject * obj0 = 0 ;
50446 PyObject * obj1 = 0 ;
50447 PyObject * obj2 = 0 ;
50448 char * kwnames[] = {
50449 (char *) "self",(char *) "row",(char *) "col", NULL
50450 };
50451
50452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50454 if (!SWIG_IsOK(res1)) {
50455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50456 }
50457 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50458 ecode2 = SWIG_AsVal_int(obj1, &val2);
50459 if (!SWIG_IsOK(ecode2)) {
50460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50461 }
50462 arg2 = static_cast< int >(val2);
50463 ecode3 = SWIG_AsVal_int(obj2, &val3);
50464 if (!SWIG_IsOK(ecode3)) {
50465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50466 }
50467 arg3 = static_cast< int >(val3);
50468 {
50469 PyThreadState* __tstate = wxPyBeginAllowThreads();
50470 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50471 wxPyEndAllowThreads(__tstate);
50472 if (PyErr_Occurred()) SWIG_fail;
50473 }
50474 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50475 return resultobj;
50476 fail:
50477 return NULL;
50478 }
50479
50480
50481 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50482 PyObject *resultobj = 0;
50483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50484 wxSize result;
50485 void *argp1 = 0 ;
50486 int res1 = 0 ;
50487 PyObject *swig_obj[1] ;
50488
50489 if (!args) SWIG_fail;
50490 swig_obj[0] = args;
50491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50492 if (!SWIG_IsOK(res1)) {
50493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50494 }
50495 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50496 {
50497 PyThreadState* __tstate = wxPyBeginAllowThreads();
50498 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50499 wxPyEndAllowThreads(__tstate);
50500 if (PyErr_Occurred()) SWIG_fail;
50501 }
50502 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50503 return resultobj;
50504 fail:
50505 return NULL;
50506 }
50507
50508
50509 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50510 PyObject *resultobj = 0;
50511 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50512 wxSize *arg2 = 0 ;
50513 void *argp1 = 0 ;
50514 int res1 = 0 ;
50515 wxSize temp2 ;
50516 PyObject * obj0 = 0 ;
50517 PyObject * obj1 = 0 ;
50518 char * kwnames[] = {
50519 (char *) "self",(char *) "sz", NULL
50520 };
50521
50522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50524 if (!SWIG_IsOK(res1)) {
50525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50526 }
50527 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50528 {
50529 arg2 = &temp2;
50530 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50531 }
50532 {
50533 PyThreadState* __tstate = wxPyBeginAllowThreads();
50534 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50535 wxPyEndAllowThreads(__tstate);
50536 if (PyErr_Occurred()) SWIG_fail;
50537 }
50538 resultobj = SWIG_Py_Void();
50539 return resultobj;
50540 fail:
50541 return NULL;
50542 }
50543
50544
50545 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50546 PyObject *resultobj = 0;
50547 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50548 wxWindow *arg2 = (wxWindow *) 0 ;
50549 wxGBPosition result;
50550 void *argp1 = 0 ;
50551 int res1 = 0 ;
50552 void *argp2 = 0 ;
50553 int res2 = 0 ;
50554
50555 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50557 if (!SWIG_IsOK(res1)) {
50558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50559 }
50560 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50561 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50562 if (!SWIG_IsOK(res2)) {
50563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50564 }
50565 arg2 = reinterpret_cast< wxWindow * >(argp2);
50566 {
50567 PyThreadState* __tstate = wxPyBeginAllowThreads();
50568 result = (arg1)->GetItemPosition(arg2);
50569 wxPyEndAllowThreads(__tstate);
50570 if (PyErr_Occurred()) SWIG_fail;
50571 }
50572 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50573 return resultobj;
50574 fail:
50575 return NULL;
50576 }
50577
50578
50579 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50580 PyObject *resultobj = 0;
50581 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50582 wxSizer *arg2 = (wxSizer *) 0 ;
50583 wxGBPosition result;
50584 void *argp1 = 0 ;
50585 int res1 = 0 ;
50586 void *argp2 = 0 ;
50587 int res2 = 0 ;
50588
50589 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50591 if (!SWIG_IsOK(res1)) {
50592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50593 }
50594 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50595 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50596 if (!SWIG_IsOK(res2)) {
50597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50598 }
50599 arg2 = reinterpret_cast< wxSizer * >(argp2);
50600 {
50601 PyThreadState* __tstate = wxPyBeginAllowThreads();
50602 result = (arg1)->GetItemPosition(arg2);
50603 wxPyEndAllowThreads(__tstate);
50604 if (PyErr_Occurred()) SWIG_fail;
50605 }
50606 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50607 return resultobj;
50608 fail:
50609 return NULL;
50610 }
50611
50612
50613 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50614 PyObject *resultobj = 0;
50615 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50616 size_t arg2 ;
50617 wxGBPosition result;
50618 void *argp1 = 0 ;
50619 int res1 = 0 ;
50620 size_t val2 ;
50621 int ecode2 = 0 ;
50622
50623 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50625 if (!SWIG_IsOK(res1)) {
50626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50627 }
50628 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50629 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50630 if (!SWIG_IsOK(ecode2)) {
50631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50632 }
50633 arg2 = static_cast< size_t >(val2);
50634 {
50635 PyThreadState* __tstate = wxPyBeginAllowThreads();
50636 result = (arg1)->GetItemPosition(arg2);
50637 wxPyEndAllowThreads(__tstate);
50638 if (PyErr_Occurred()) SWIG_fail;
50639 }
50640 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50641 return resultobj;
50642 fail:
50643 return NULL;
50644 }
50645
50646
50647 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50648 int argc;
50649 PyObject *argv[3];
50650
50651 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50652 --argc;
50653 if (argc == 2) {
50654 int _v = 0;
50655 {
50656 void *vptr = 0;
50657 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50658 _v = SWIG_CheckState(res);
50659 }
50660 if (!_v) goto check_1;
50661 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50662 }
50663 check_1:
50664
50665 if (argc == 2) {
50666 int _v = 0;
50667 {
50668 void *vptr = 0;
50669 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50670 _v = SWIG_CheckState(res);
50671 }
50672 if (!_v) goto check_2;
50673 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50674 }
50675 check_2:
50676
50677 if (argc == 2) {
50678 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50679 }
50680
50681 fail:
50682 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50683 return NULL;
50684 }
50685
50686
50687 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50688 PyObject *resultobj = 0;
50689 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50690 wxWindow *arg2 = (wxWindow *) 0 ;
50691 wxGBPosition *arg3 = 0 ;
50692 bool result;
50693 void *argp1 = 0 ;
50694 int res1 = 0 ;
50695 void *argp2 = 0 ;
50696 int res2 = 0 ;
50697 wxGBPosition temp3 ;
50698
50699 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50701 if (!SWIG_IsOK(res1)) {
50702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50703 }
50704 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50705 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50706 if (!SWIG_IsOK(res2)) {
50707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50708 }
50709 arg2 = reinterpret_cast< wxWindow * >(argp2);
50710 {
50711 arg3 = &temp3;
50712 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50713 }
50714 {
50715 PyThreadState* __tstate = wxPyBeginAllowThreads();
50716 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50717 wxPyEndAllowThreads(__tstate);
50718 if (PyErr_Occurred()) SWIG_fail;
50719 }
50720 {
50721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50722 }
50723 return resultobj;
50724 fail:
50725 return NULL;
50726 }
50727
50728
50729 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50730 PyObject *resultobj = 0;
50731 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50732 wxSizer *arg2 = (wxSizer *) 0 ;
50733 wxGBPosition *arg3 = 0 ;
50734 bool result;
50735 void *argp1 = 0 ;
50736 int res1 = 0 ;
50737 void *argp2 = 0 ;
50738 int res2 = 0 ;
50739 wxGBPosition temp3 ;
50740
50741 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50743 if (!SWIG_IsOK(res1)) {
50744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50745 }
50746 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50747 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50748 if (!SWIG_IsOK(res2)) {
50749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50750 }
50751 arg2 = reinterpret_cast< wxSizer * >(argp2);
50752 {
50753 arg3 = &temp3;
50754 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50755 }
50756 {
50757 PyThreadState* __tstate = wxPyBeginAllowThreads();
50758 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50759 wxPyEndAllowThreads(__tstate);
50760 if (PyErr_Occurred()) SWIG_fail;
50761 }
50762 {
50763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50764 }
50765 return resultobj;
50766 fail:
50767 return NULL;
50768 }
50769
50770
50771 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50772 PyObject *resultobj = 0;
50773 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50774 size_t arg2 ;
50775 wxGBPosition *arg3 = 0 ;
50776 bool result;
50777 void *argp1 = 0 ;
50778 int res1 = 0 ;
50779 size_t val2 ;
50780 int ecode2 = 0 ;
50781 wxGBPosition temp3 ;
50782
50783 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50785 if (!SWIG_IsOK(res1)) {
50786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50787 }
50788 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50789 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50790 if (!SWIG_IsOK(ecode2)) {
50791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50792 }
50793 arg2 = static_cast< size_t >(val2);
50794 {
50795 arg3 = &temp3;
50796 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50797 }
50798 {
50799 PyThreadState* __tstate = wxPyBeginAllowThreads();
50800 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50801 wxPyEndAllowThreads(__tstate);
50802 if (PyErr_Occurred()) SWIG_fail;
50803 }
50804 {
50805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50806 }
50807 return resultobj;
50808 fail:
50809 return NULL;
50810 }
50811
50812
50813 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50814 int argc;
50815 PyObject *argv[4];
50816
50817 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50818 --argc;
50819 if (argc == 3) {
50820 int _v = 0;
50821 {
50822 void *vptr = 0;
50823 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50824 _v = SWIG_CheckState(res);
50825 }
50826 if (!_v) goto check_1;
50827 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50828 }
50829 check_1:
50830
50831 if (argc == 3) {
50832 int _v = 0;
50833 {
50834 void *vptr = 0;
50835 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50836 _v = SWIG_CheckState(res);
50837 }
50838 if (!_v) goto check_2;
50839 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50840 }
50841 check_2:
50842
50843 if (argc == 3) {
50844 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50845 }
50846
50847 fail:
50848 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50849 return NULL;
50850 }
50851
50852
50853 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50854 PyObject *resultobj = 0;
50855 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50856 wxWindow *arg2 = (wxWindow *) 0 ;
50857 wxGBSpan result;
50858 void *argp1 = 0 ;
50859 int res1 = 0 ;
50860 void *argp2 = 0 ;
50861 int res2 = 0 ;
50862
50863 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50865 if (!SWIG_IsOK(res1)) {
50866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50867 }
50868 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50869 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50870 if (!SWIG_IsOK(res2)) {
50871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50872 }
50873 arg2 = reinterpret_cast< wxWindow * >(argp2);
50874 {
50875 PyThreadState* __tstate = wxPyBeginAllowThreads();
50876 result = (arg1)->GetItemSpan(arg2);
50877 wxPyEndAllowThreads(__tstate);
50878 if (PyErr_Occurred()) SWIG_fail;
50879 }
50880 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50881 return resultobj;
50882 fail:
50883 return NULL;
50884 }
50885
50886
50887 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50888 PyObject *resultobj = 0;
50889 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50890 wxSizer *arg2 = (wxSizer *) 0 ;
50891 wxGBSpan result;
50892 void *argp1 = 0 ;
50893 int res1 = 0 ;
50894 void *argp2 = 0 ;
50895 int res2 = 0 ;
50896
50897 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50899 if (!SWIG_IsOK(res1)) {
50900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50901 }
50902 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50903 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50904 if (!SWIG_IsOK(res2)) {
50905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50906 }
50907 arg2 = reinterpret_cast< wxSizer * >(argp2);
50908 {
50909 PyThreadState* __tstate = wxPyBeginAllowThreads();
50910 result = (arg1)->GetItemSpan(arg2);
50911 wxPyEndAllowThreads(__tstate);
50912 if (PyErr_Occurred()) SWIG_fail;
50913 }
50914 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50915 return resultobj;
50916 fail:
50917 return NULL;
50918 }
50919
50920
50921 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50922 PyObject *resultobj = 0;
50923 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50924 size_t arg2 ;
50925 wxGBSpan result;
50926 void *argp1 = 0 ;
50927 int res1 = 0 ;
50928 size_t val2 ;
50929 int ecode2 = 0 ;
50930
50931 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50935 }
50936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50937 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50938 if (!SWIG_IsOK(ecode2)) {
50939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50940 }
50941 arg2 = static_cast< size_t >(val2);
50942 {
50943 PyThreadState* __tstate = wxPyBeginAllowThreads();
50944 result = (arg1)->GetItemSpan(arg2);
50945 wxPyEndAllowThreads(__tstate);
50946 if (PyErr_Occurred()) SWIG_fail;
50947 }
50948 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50949 return resultobj;
50950 fail:
50951 return NULL;
50952 }
50953
50954
50955 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50956 int argc;
50957 PyObject *argv[3];
50958
50959 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50960 --argc;
50961 if (argc == 2) {
50962 int _v = 0;
50963 {
50964 void *vptr = 0;
50965 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50966 _v = SWIG_CheckState(res);
50967 }
50968 if (!_v) goto check_1;
50969 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50970 }
50971 check_1:
50972
50973 if (argc == 2) {
50974 int _v = 0;
50975 {
50976 void *vptr = 0;
50977 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50978 _v = SWIG_CheckState(res);
50979 }
50980 if (!_v) goto check_2;
50981 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50982 }
50983 check_2:
50984
50985 if (argc == 2) {
50986 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50987 }
50988
50989 fail:
50990 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50991 return NULL;
50992 }
50993
50994
50995 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50996 PyObject *resultobj = 0;
50997 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50998 wxWindow *arg2 = (wxWindow *) 0 ;
50999 wxGBSpan *arg3 = 0 ;
51000 bool result;
51001 void *argp1 = 0 ;
51002 int res1 = 0 ;
51003 void *argp2 = 0 ;
51004 int res2 = 0 ;
51005 wxGBSpan 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_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51011 }
51012 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51013 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51014 if (!SWIG_IsOK(res2)) {
51015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51016 }
51017 arg2 = reinterpret_cast< wxWindow * >(argp2);
51018 {
51019 arg3 = &temp3;
51020 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51021 }
51022 {
51023 PyThreadState* __tstate = wxPyBeginAllowThreads();
51024 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan 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_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51038 PyObject *resultobj = 0;
51039 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51040 wxSizer *arg2 = (wxSizer *) 0 ;
51041 wxGBSpan *arg3 = 0 ;
51042 bool result;
51043 void *argp1 = 0 ;
51044 int res1 = 0 ;
51045 void *argp2 = 0 ;
51046 int res2 = 0 ;
51047 wxGBSpan temp3 ;
51048
51049 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51051 if (!SWIG_IsOK(res1)) {
51052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51053 }
51054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51055 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51056 if (!SWIG_IsOK(res2)) {
51057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51058 }
51059 arg2 = reinterpret_cast< wxSizer * >(argp2);
51060 {
51061 arg3 = &temp3;
51062 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51063 }
51064 {
51065 PyThreadState* __tstate = wxPyBeginAllowThreads();
51066 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51067 wxPyEndAllowThreads(__tstate);
51068 if (PyErr_Occurred()) SWIG_fail;
51069 }
51070 {
51071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51072 }
51073 return resultobj;
51074 fail:
51075 return NULL;
51076 }
51077
51078
51079 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51080 PyObject *resultobj = 0;
51081 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51082 size_t arg2 ;
51083 wxGBSpan *arg3 = 0 ;
51084 bool result;
51085 void *argp1 = 0 ;
51086 int res1 = 0 ;
51087 size_t val2 ;
51088 int ecode2 = 0 ;
51089 wxGBSpan temp3 ;
51090
51091 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51093 if (!SWIG_IsOK(res1)) {
51094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51095 }
51096 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51097 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51098 if (!SWIG_IsOK(ecode2)) {
51099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51100 }
51101 arg2 = static_cast< size_t >(val2);
51102 {
51103 arg3 = &temp3;
51104 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51105 }
51106 {
51107 PyThreadState* __tstate = wxPyBeginAllowThreads();
51108 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51109 wxPyEndAllowThreads(__tstate);
51110 if (PyErr_Occurred()) SWIG_fail;
51111 }
51112 {
51113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51114 }
51115 return resultobj;
51116 fail:
51117 return NULL;
51118 }
51119
51120
51121 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51122 int argc;
51123 PyObject *argv[4];
51124
51125 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51126 --argc;
51127 if (argc == 3) {
51128 int _v = 0;
51129 {
51130 void *vptr = 0;
51131 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51132 _v = SWIG_CheckState(res);
51133 }
51134 if (!_v) goto check_1;
51135 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51136 }
51137 check_1:
51138
51139 if (argc == 3) {
51140 int _v = 0;
51141 {
51142 void *vptr = 0;
51143 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51144 _v = SWIG_CheckState(res);
51145 }
51146 if (!_v) goto check_2;
51147 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51148 }
51149 check_2:
51150
51151 if (argc == 3) {
51152 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51153 }
51154
51155 fail:
51156 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51157 return NULL;
51158 }
51159
51160
51161 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51162 PyObject *resultobj = 0;
51163 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51164 wxWindow *arg2 = (wxWindow *) 0 ;
51165 wxGBSizerItem *result = 0 ;
51166 void *argp1 = 0 ;
51167 int res1 = 0 ;
51168 void *argp2 = 0 ;
51169 int res2 = 0 ;
51170
51171 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51173 if (!SWIG_IsOK(res1)) {
51174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51175 }
51176 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51177 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51178 if (!SWIG_IsOK(res2)) {
51179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51180 }
51181 arg2 = reinterpret_cast< wxWindow * >(argp2);
51182 {
51183 PyThreadState* __tstate = wxPyBeginAllowThreads();
51184 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51185 wxPyEndAllowThreads(__tstate);
51186 if (PyErr_Occurred()) SWIG_fail;
51187 }
51188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51189 return resultobj;
51190 fail:
51191 return NULL;
51192 }
51193
51194
51195 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51196 PyObject *resultobj = 0;
51197 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51198 wxSizer *arg2 = (wxSizer *) 0 ;
51199 wxGBSizerItem *result = 0 ;
51200 void *argp1 = 0 ;
51201 int res1 = 0 ;
51202 void *argp2 = 0 ;
51203 int res2 = 0 ;
51204
51205 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51207 if (!SWIG_IsOK(res1)) {
51208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51209 }
51210 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51211 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51212 if (!SWIG_IsOK(res2)) {
51213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51214 }
51215 arg2 = reinterpret_cast< wxSizer * >(argp2);
51216 {
51217 PyThreadState* __tstate = wxPyBeginAllowThreads();
51218 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51219 wxPyEndAllowThreads(__tstate);
51220 if (PyErr_Occurred()) SWIG_fail;
51221 }
51222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51223 return resultobj;
51224 fail:
51225 return NULL;
51226 }
51227
51228
51229 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51230 int argc;
51231 PyObject *argv[3];
51232
51233 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51234 --argc;
51235 if (argc == 2) {
51236 int _v = 0;
51237 {
51238 void *vptr = 0;
51239 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51240 _v = SWIG_CheckState(res);
51241 }
51242 if (!_v) goto check_1;
51243 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51244 }
51245 check_1:
51246
51247 if (argc == 2) {
51248 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51249 }
51250
51251 fail:
51252 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51253 return NULL;
51254 }
51255
51256
51257 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51258 PyObject *resultobj = 0;
51259 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51260 wxGBPosition *arg2 = 0 ;
51261 wxGBSizerItem *result = 0 ;
51262 void *argp1 = 0 ;
51263 int res1 = 0 ;
51264 wxGBPosition temp2 ;
51265 PyObject * obj0 = 0 ;
51266 PyObject * obj1 = 0 ;
51267 char * kwnames[] = {
51268 (char *) "self",(char *) "pos", NULL
51269 };
51270
51271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51273 if (!SWIG_IsOK(res1)) {
51274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51275 }
51276 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51277 {
51278 arg2 = &temp2;
51279 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51280 }
51281 {
51282 PyThreadState* __tstate = wxPyBeginAllowThreads();
51283 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51284 wxPyEndAllowThreads(__tstate);
51285 if (PyErr_Occurred()) SWIG_fail;
51286 }
51287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51288 return resultobj;
51289 fail:
51290 return NULL;
51291 }
51292
51293
51294 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51295 PyObject *resultobj = 0;
51296 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51297 wxPoint *arg2 = 0 ;
51298 wxGBSizerItem *result = 0 ;
51299 void *argp1 = 0 ;
51300 int res1 = 0 ;
51301 wxPoint temp2 ;
51302 PyObject * obj0 = 0 ;
51303 PyObject * obj1 = 0 ;
51304 char * kwnames[] = {
51305 (char *) "self",(char *) "pt", NULL
51306 };
51307
51308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51310 if (!SWIG_IsOK(res1)) {
51311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51312 }
51313 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51314 {
51315 arg2 = &temp2;
51316 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51317 }
51318 {
51319 PyThreadState* __tstate = wxPyBeginAllowThreads();
51320 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51321 wxPyEndAllowThreads(__tstate);
51322 if (PyErr_Occurred()) SWIG_fail;
51323 }
51324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51325 return resultobj;
51326 fail:
51327 return NULL;
51328 }
51329
51330
51331 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51332 PyObject *resultobj = 0;
51333 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51334 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51335 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51336 bool result;
51337 void *argp1 = 0 ;
51338 int res1 = 0 ;
51339 void *argp2 = 0 ;
51340 int res2 = 0 ;
51341 void *argp3 = 0 ;
51342 int res3 = 0 ;
51343 PyObject * obj0 = 0 ;
51344 PyObject * obj1 = 0 ;
51345 PyObject * obj2 = 0 ;
51346 char * kwnames[] = {
51347 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51348 };
51349
51350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51352 if (!SWIG_IsOK(res1)) {
51353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51354 }
51355 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51357 if (!SWIG_IsOK(res2)) {
51358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51359 }
51360 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51361 if (obj2) {
51362 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51363 if (!SWIG_IsOK(res3)) {
51364 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51365 }
51366 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51367 }
51368 {
51369 PyThreadState* __tstate = wxPyBeginAllowThreads();
51370 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51371 wxPyEndAllowThreads(__tstate);
51372 if (PyErr_Occurred()) SWIG_fail;
51373 }
51374 {
51375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51376 }
51377 return resultobj;
51378 fail:
51379 return NULL;
51380 }
51381
51382
51383 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51384 PyObject *resultobj = 0;
51385 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51386 wxGBPosition *arg2 = 0 ;
51387 wxGBSpan *arg3 = 0 ;
51388 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51389 bool result;
51390 void *argp1 = 0 ;
51391 int res1 = 0 ;
51392 wxGBPosition temp2 ;
51393 wxGBSpan temp3 ;
51394 void *argp4 = 0 ;
51395 int res4 = 0 ;
51396 PyObject * obj0 = 0 ;
51397 PyObject * obj1 = 0 ;
51398 PyObject * obj2 = 0 ;
51399 PyObject * obj3 = 0 ;
51400 char * kwnames[] = {
51401 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51402 };
51403
51404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51406 if (!SWIG_IsOK(res1)) {
51407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51408 }
51409 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51410 {
51411 arg2 = &temp2;
51412 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51413 }
51414 {
51415 arg3 = &temp3;
51416 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51417 }
51418 if (obj3) {
51419 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51420 if (!SWIG_IsOK(res4)) {
51421 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51422 }
51423 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51424 }
51425 {
51426 PyThreadState* __tstate = wxPyBeginAllowThreads();
51427 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51428 wxPyEndAllowThreads(__tstate);
51429 if (PyErr_Occurred()) SWIG_fail;
51430 }
51431 {
51432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51433 }
51434 return resultobj;
51435 fail:
51436 return NULL;
51437 }
51438
51439
51440 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51441 PyObject *obj;
51442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51443 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51444 return SWIG_Py_Void();
51445 }
51446
51447 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51448 return SWIG_Python_InitShadowInstance(args);
51449 }
51450
51451 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51452 PyObject *resultobj = 0;
51453 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51454 wxRelationship arg2 ;
51455 wxWindow *arg3 = (wxWindow *) 0 ;
51456 wxEdge arg4 ;
51457 int arg5 = (int) 0 ;
51458 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51459 void *argp1 = 0 ;
51460 int res1 = 0 ;
51461 int val2 ;
51462 int ecode2 = 0 ;
51463 void *argp3 = 0 ;
51464 int res3 = 0 ;
51465 int val4 ;
51466 int ecode4 = 0 ;
51467 int val5 ;
51468 int ecode5 = 0 ;
51469 int val6 ;
51470 int ecode6 = 0 ;
51471 PyObject * obj0 = 0 ;
51472 PyObject * obj1 = 0 ;
51473 PyObject * obj2 = 0 ;
51474 PyObject * obj3 = 0 ;
51475 PyObject * obj4 = 0 ;
51476 PyObject * obj5 = 0 ;
51477 char * kwnames[] = {
51478 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51479 };
51480
51481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51483 if (!SWIG_IsOK(res1)) {
51484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51485 }
51486 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51487 ecode2 = SWIG_AsVal_int(obj1, &val2);
51488 if (!SWIG_IsOK(ecode2)) {
51489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51490 }
51491 arg2 = static_cast< wxRelationship >(val2);
51492 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51493 if (!SWIG_IsOK(res3)) {
51494 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51495 }
51496 arg3 = reinterpret_cast< wxWindow * >(argp3);
51497 ecode4 = SWIG_AsVal_int(obj3, &val4);
51498 if (!SWIG_IsOK(ecode4)) {
51499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51500 }
51501 arg4 = static_cast< wxEdge >(val4);
51502 if (obj4) {
51503 ecode5 = SWIG_AsVal_int(obj4, &val5);
51504 if (!SWIG_IsOK(ecode5)) {
51505 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51506 }
51507 arg5 = static_cast< int >(val5);
51508 }
51509 if (obj5) {
51510 ecode6 = SWIG_AsVal_int(obj5, &val6);
51511 if (!SWIG_IsOK(ecode6)) {
51512 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51513 }
51514 arg6 = static_cast< int >(val6);
51515 }
51516 {
51517 PyThreadState* __tstate = wxPyBeginAllowThreads();
51518 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51519 wxPyEndAllowThreads(__tstate);
51520 if (PyErr_Occurred()) SWIG_fail;
51521 }
51522 resultobj = SWIG_Py_Void();
51523 return resultobj;
51524 fail:
51525 return NULL;
51526 }
51527
51528
51529 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51530 PyObject *resultobj = 0;
51531 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51532 wxWindow *arg2 = (wxWindow *) 0 ;
51533 int arg3 = (int) 0 ;
51534 void *argp1 = 0 ;
51535 int res1 = 0 ;
51536 void *argp2 = 0 ;
51537 int res2 = 0 ;
51538 int val3 ;
51539 int ecode3 = 0 ;
51540 PyObject * obj0 = 0 ;
51541 PyObject * obj1 = 0 ;
51542 PyObject * obj2 = 0 ;
51543 char * kwnames[] = {
51544 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51545 };
51546
51547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51549 if (!SWIG_IsOK(res1)) {
51550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51551 }
51552 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51554 if (!SWIG_IsOK(res2)) {
51555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51556 }
51557 arg2 = reinterpret_cast< wxWindow * >(argp2);
51558 if (obj2) {
51559 ecode3 = SWIG_AsVal_int(obj2, &val3);
51560 if (!SWIG_IsOK(ecode3)) {
51561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51562 }
51563 arg3 = static_cast< int >(val3);
51564 }
51565 {
51566 PyThreadState* __tstate = wxPyBeginAllowThreads();
51567 (arg1)->LeftOf(arg2,arg3);
51568 wxPyEndAllowThreads(__tstate);
51569 if (PyErr_Occurred()) SWIG_fail;
51570 }
51571 resultobj = SWIG_Py_Void();
51572 return resultobj;
51573 fail:
51574 return NULL;
51575 }
51576
51577
51578 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51579 PyObject *resultobj = 0;
51580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51581 wxWindow *arg2 = (wxWindow *) 0 ;
51582 int arg3 = (int) 0 ;
51583 void *argp1 = 0 ;
51584 int res1 = 0 ;
51585 void *argp2 = 0 ;
51586 int res2 = 0 ;
51587 int val3 ;
51588 int ecode3 = 0 ;
51589 PyObject * obj0 = 0 ;
51590 PyObject * obj1 = 0 ;
51591 PyObject * obj2 = 0 ;
51592 char * kwnames[] = {
51593 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51594 };
51595
51596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51598 if (!SWIG_IsOK(res1)) {
51599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51600 }
51601 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51603 if (!SWIG_IsOK(res2)) {
51604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51605 }
51606 arg2 = reinterpret_cast< wxWindow * >(argp2);
51607 if (obj2) {
51608 ecode3 = SWIG_AsVal_int(obj2, &val3);
51609 if (!SWIG_IsOK(ecode3)) {
51610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51611 }
51612 arg3 = static_cast< int >(val3);
51613 }
51614 {
51615 PyThreadState* __tstate = wxPyBeginAllowThreads();
51616 (arg1)->RightOf(arg2,arg3);
51617 wxPyEndAllowThreads(__tstate);
51618 if (PyErr_Occurred()) SWIG_fail;
51619 }
51620 resultobj = SWIG_Py_Void();
51621 return resultobj;
51622 fail:
51623 return NULL;
51624 }
51625
51626
51627 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51628 PyObject *resultobj = 0;
51629 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51630 wxWindow *arg2 = (wxWindow *) 0 ;
51631 int arg3 = (int) 0 ;
51632 void *argp1 = 0 ;
51633 int res1 = 0 ;
51634 void *argp2 = 0 ;
51635 int res2 = 0 ;
51636 int val3 ;
51637 int ecode3 = 0 ;
51638 PyObject * obj0 = 0 ;
51639 PyObject * obj1 = 0 ;
51640 PyObject * obj2 = 0 ;
51641 char * kwnames[] = {
51642 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51643 };
51644
51645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51647 if (!SWIG_IsOK(res1)) {
51648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51649 }
51650 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51652 if (!SWIG_IsOK(res2)) {
51653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51654 }
51655 arg2 = reinterpret_cast< wxWindow * >(argp2);
51656 if (obj2) {
51657 ecode3 = SWIG_AsVal_int(obj2, &val3);
51658 if (!SWIG_IsOK(ecode3)) {
51659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51660 }
51661 arg3 = static_cast< int >(val3);
51662 }
51663 {
51664 PyThreadState* __tstate = wxPyBeginAllowThreads();
51665 (arg1)->Above(arg2,arg3);
51666 wxPyEndAllowThreads(__tstate);
51667 if (PyErr_Occurred()) SWIG_fail;
51668 }
51669 resultobj = SWIG_Py_Void();
51670 return resultobj;
51671 fail:
51672 return NULL;
51673 }
51674
51675
51676 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51677 PyObject *resultobj = 0;
51678 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51679 wxWindow *arg2 = (wxWindow *) 0 ;
51680 int arg3 = (int) 0 ;
51681 void *argp1 = 0 ;
51682 int res1 = 0 ;
51683 void *argp2 = 0 ;
51684 int res2 = 0 ;
51685 int val3 ;
51686 int ecode3 = 0 ;
51687 PyObject * obj0 = 0 ;
51688 PyObject * obj1 = 0 ;
51689 PyObject * obj2 = 0 ;
51690 char * kwnames[] = {
51691 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51692 };
51693
51694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51696 if (!SWIG_IsOK(res1)) {
51697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51698 }
51699 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51700 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51701 if (!SWIG_IsOK(res2)) {
51702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51703 }
51704 arg2 = reinterpret_cast< wxWindow * >(argp2);
51705 if (obj2) {
51706 ecode3 = SWIG_AsVal_int(obj2, &val3);
51707 if (!SWIG_IsOK(ecode3)) {
51708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51709 }
51710 arg3 = static_cast< int >(val3);
51711 }
51712 {
51713 PyThreadState* __tstate = wxPyBeginAllowThreads();
51714 (arg1)->Below(arg2,arg3);
51715 wxPyEndAllowThreads(__tstate);
51716 if (PyErr_Occurred()) SWIG_fail;
51717 }
51718 resultobj = SWIG_Py_Void();
51719 return resultobj;
51720 fail:
51721 return NULL;
51722 }
51723
51724
51725 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51726 PyObject *resultobj = 0;
51727 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51728 wxWindow *arg2 = (wxWindow *) 0 ;
51729 wxEdge arg3 ;
51730 int arg4 = (int) 0 ;
51731 void *argp1 = 0 ;
51732 int res1 = 0 ;
51733 void *argp2 = 0 ;
51734 int res2 = 0 ;
51735 int val3 ;
51736 int ecode3 = 0 ;
51737 int val4 ;
51738 int ecode4 = 0 ;
51739 PyObject * obj0 = 0 ;
51740 PyObject * obj1 = 0 ;
51741 PyObject * obj2 = 0 ;
51742 PyObject * obj3 = 0 ;
51743 char * kwnames[] = {
51744 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51745 };
51746
51747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51749 if (!SWIG_IsOK(res1)) {
51750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51751 }
51752 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51754 if (!SWIG_IsOK(res2)) {
51755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51756 }
51757 arg2 = reinterpret_cast< wxWindow * >(argp2);
51758 ecode3 = SWIG_AsVal_int(obj2, &val3);
51759 if (!SWIG_IsOK(ecode3)) {
51760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51761 }
51762 arg3 = static_cast< wxEdge >(val3);
51763 if (obj3) {
51764 ecode4 = SWIG_AsVal_int(obj3, &val4);
51765 if (!SWIG_IsOK(ecode4)) {
51766 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51767 }
51768 arg4 = static_cast< int >(val4);
51769 }
51770 {
51771 PyThreadState* __tstate = wxPyBeginAllowThreads();
51772 (arg1)->SameAs(arg2,arg3,arg4);
51773 wxPyEndAllowThreads(__tstate);
51774 if (PyErr_Occurred()) SWIG_fail;
51775 }
51776 resultobj = SWIG_Py_Void();
51777 return resultobj;
51778 fail:
51779 return NULL;
51780 }
51781
51782
51783 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51784 PyObject *resultobj = 0;
51785 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51786 wxWindow *arg2 = (wxWindow *) 0 ;
51787 wxEdge arg3 ;
51788 int arg4 ;
51789 void *argp1 = 0 ;
51790 int res1 = 0 ;
51791 void *argp2 = 0 ;
51792 int res2 = 0 ;
51793 int val3 ;
51794 int ecode3 = 0 ;
51795 int val4 ;
51796 int ecode4 = 0 ;
51797 PyObject * obj0 = 0 ;
51798 PyObject * obj1 = 0 ;
51799 PyObject * obj2 = 0 ;
51800 PyObject * obj3 = 0 ;
51801 char * kwnames[] = {
51802 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51803 };
51804
51805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51807 if (!SWIG_IsOK(res1)) {
51808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51809 }
51810 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51812 if (!SWIG_IsOK(res2)) {
51813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51814 }
51815 arg2 = reinterpret_cast< wxWindow * >(argp2);
51816 ecode3 = SWIG_AsVal_int(obj2, &val3);
51817 if (!SWIG_IsOK(ecode3)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51819 }
51820 arg3 = static_cast< wxEdge >(val3);
51821 ecode4 = SWIG_AsVal_int(obj3, &val4);
51822 if (!SWIG_IsOK(ecode4)) {
51823 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51824 }
51825 arg4 = static_cast< int >(val4);
51826 {
51827 PyThreadState* __tstate = wxPyBeginAllowThreads();
51828 (arg1)->PercentOf(arg2,arg3,arg4);
51829 wxPyEndAllowThreads(__tstate);
51830 if (PyErr_Occurred()) SWIG_fail;
51831 }
51832 resultobj = SWIG_Py_Void();
51833 return resultobj;
51834 fail:
51835 return NULL;
51836 }
51837
51838
51839 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51840 PyObject *resultobj = 0;
51841 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51842 int arg2 ;
51843 void *argp1 = 0 ;
51844 int res1 = 0 ;
51845 int val2 ;
51846 int ecode2 = 0 ;
51847 PyObject * obj0 = 0 ;
51848 PyObject * obj1 = 0 ;
51849 char * kwnames[] = {
51850 (char *) "self",(char *) "val", NULL
51851 };
51852
51853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51855 if (!SWIG_IsOK(res1)) {
51856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51857 }
51858 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51859 ecode2 = SWIG_AsVal_int(obj1, &val2);
51860 if (!SWIG_IsOK(ecode2)) {
51861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51862 }
51863 arg2 = static_cast< int >(val2);
51864 {
51865 PyThreadState* __tstate = wxPyBeginAllowThreads();
51866 (arg1)->Absolute(arg2);
51867 wxPyEndAllowThreads(__tstate);
51868 if (PyErr_Occurred()) SWIG_fail;
51869 }
51870 resultobj = SWIG_Py_Void();
51871 return resultobj;
51872 fail:
51873 return NULL;
51874 }
51875
51876
51877 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51878 PyObject *resultobj = 0;
51879 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51880 void *argp1 = 0 ;
51881 int res1 = 0 ;
51882 PyObject *swig_obj[1] ;
51883
51884 if (!args) SWIG_fail;
51885 swig_obj[0] = args;
51886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51887 if (!SWIG_IsOK(res1)) {
51888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51889 }
51890 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51891 {
51892 PyThreadState* __tstate = wxPyBeginAllowThreads();
51893 (arg1)->Unconstrained();
51894 wxPyEndAllowThreads(__tstate);
51895 if (PyErr_Occurred()) SWIG_fail;
51896 }
51897 resultobj = SWIG_Py_Void();
51898 return resultobj;
51899 fail:
51900 return NULL;
51901 }
51902
51903
51904 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51905 PyObject *resultobj = 0;
51906 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51907 void *argp1 = 0 ;
51908 int res1 = 0 ;
51909 PyObject *swig_obj[1] ;
51910
51911 if (!args) SWIG_fail;
51912 swig_obj[0] = args;
51913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51914 if (!SWIG_IsOK(res1)) {
51915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51916 }
51917 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51918 {
51919 PyThreadState* __tstate = wxPyBeginAllowThreads();
51920 (arg1)->AsIs();
51921 wxPyEndAllowThreads(__tstate);
51922 if (PyErr_Occurred()) SWIG_fail;
51923 }
51924 resultobj = SWIG_Py_Void();
51925 return resultobj;
51926 fail:
51927 return NULL;
51928 }
51929
51930
51931 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51932 PyObject *resultobj = 0;
51933 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51934 wxWindow *result = 0 ;
51935 void *argp1 = 0 ;
51936 int res1 = 0 ;
51937 PyObject *swig_obj[1] ;
51938
51939 if (!args) SWIG_fail;
51940 swig_obj[0] = args;
51941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51942 if (!SWIG_IsOK(res1)) {
51943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51944 }
51945 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51946 {
51947 PyThreadState* __tstate = wxPyBeginAllowThreads();
51948 result = (wxWindow *)(arg1)->GetOtherWindow();
51949 wxPyEndAllowThreads(__tstate);
51950 if (PyErr_Occurred()) SWIG_fail;
51951 }
51952 {
51953 resultobj = wxPyMake_wxObject(result, 0);
51954 }
51955 return resultobj;
51956 fail:
51957 return NULL;
51958 }
51959
51960
51961 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51962 PyObject *resultobj = 0;
51963 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51964 wxEdge result;
51965 void *argp1 = 0 ;
51966 int res1 = 0 ;
51967 PyObject *swig_obj[1] ;
51968
51969 if (!args) SWIG_fail;
51970 swig_obj[0] = args;
51971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51972 if (!SWIG_IsOK(res1)) {
51973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51974 }
51975 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51976 {
51977 PyThreadState* __tstate = wxPyBeginAllowThreads();
51978 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51979 wxPyEndAllowThreads(__tstate);
51980 if (PyErr_Occurred()) SWIG_fail;
51981 }
51982 resultobj = SWIG_From_int(static_cast< int >(result));
51983 return resultobj;
51984 fail:
51985 return NULL;
51986 }
51987
51988
51989 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51990 PyObject *resultobj = 0;
51991 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51992 wxEdge arg2 ;
51993 void *argp1 = 0 ;
51994 int res1 = 0 ;
51995 int val2 ;
51996 int ecode2 = 0 ;
51997 PyObject * obj0 = 0 ;
51998 PyObject * obj1 = 0 ;
51999 char * kwnames[] = {
52000 (char *) "self",(char *) "which", NULL
52001 };
52002
52003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52005 if (!SWIG_IsOK(res1)) {
52006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52007 }
52008 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52009 ecode2 = SWIG_AsVal_int(obj1, &val2);
52010 if (!SWIG_IsOK(ecode2)) {
52011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52012 }
52013 arg2 = static_cast< wxEdge >(val2);
52014 {
52015 PyThreadState* __tstate = wxPyBeginAllowThreads();
52016 (arg1)->SetEdge(arg2);
52017 wxPyEndAllowThreads(__tstate);
52018 if (PyErr_Occurred()) SWIG_fail;
52019 }
52020 resultobj = SWIG_Py_Void();
52021 return resultobj;
52022 fail:
52023 return NULL;
52024 }
52025
52026
52027 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52028 PyObject *resultobj = 0;
52029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52030 int arg2 ;
52031 void *argp1 = 0 ;
52032 int res1 = 0 ;
52033 int val2 ;
52034 int ecode2 = 0 ;
52035 PyObject * obj0 = 0 ;
52036 PyObject * obj1 = 0 ;
52037 char * kwnames[] = {
52038 (char *) "self",(char *) "v", NULL
52039 };
52040
52041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52043 if (!SWIG_IsOK(res1)) {
52044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52045 }
52046 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52047 ecode2 = SWIG_AsVal_int(obj1, &val2);
52048 if (!SWIG_IsOK(ecode2)) {
52049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52050 }
52051 arg2 = static_cast< int >(val2);
52052 {
52053 PyThreadState* __tstate = wxPyBeginAllowThreads();
52054 (arg1)->SetValue(arg2);
52055 wxPyEndAllowThreads(__tstate);
52056 if (PyErr_Occurred()) SWIG_fail;
52057 }
52058 resultobj = SWIG_Py_Void();
52059 return resultobj;
52060 fail:
52061 return NULL;
52062 }
52063
52064
52065 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52066 PyObject *resultobj = 0;
52067 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52068 int result;
52069 void *argp1 = 0 ;
52070 int res1 = 0 ;
52071 PyObject *swig_obj[1] ;
52072
52073 if (!args) SWIG_fail;
52074 swig_obj[0] = args;
52075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52076 if (!SWIG_IsOK(res1)) {
52077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52078 }
52079 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52080 {
52081 PyThreadState* __tstate = wxPyBeginAllowThreads();
52082 result = (int)(arg1)->GetMargin();
52083 wxPyEndAllowThreads(__tstate);
52084 if (PyErr_Occurred()) SWIG_fail;
52085 }
52086 resultobj = SWIG_From_int(static_cast< int >(result));
52087 return resultobj;
52088 fail:
52089 return NULL;
52090 }
52091
52092
52093 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52094 PyObject *resultobj = 0;
52095 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52096 int arg2 ;
52097 void *argp1 = 0 ;
52098 int res1 = 0 ;
52099 int val2 ;
52100 int ecode2 = 0 ;
52101 PyObject * obj0 = 0 ;
52102 PyObject * obj1 = 0 ;
52103 char * kwnames[] = {
52104 (char *) "self",(char *) "m", NULL
52105 };
52106
52107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52109 if (!SWIG_IsOK(res1)) {
52110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52111 }
52112 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52113 ecode2 = SWIG_AsVal_int(obj1, &val2);
52114 if (!SWIG_IsOK(ecode2)) {
52115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52116 }
52117 arg2 = static_cast< int >(val2);
52118 {
52119 PyThreadState* __tstate = wxPyBeginAllowThreads();
52120 (arg1)->SetMargin(arg2);
52121 wxPyEndAllowThreads(__tstate);
52122 if (PyErr_Occurred()) SWIG_fail;
52123 }
52124 resultobj = SWIG_Py_Void();
52125 return resultobj;
52126 fail:
52127 return NULL;
52128 }
52129
52130
52131 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52132 PyObject *resultobj = 0;
52133 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52134 int result;
52135 void *argp1 = 0 ;
52136 int res1 = 0 ;
52137 PyObject *swig_obj[1] ;
52138
52139 if (!args) SWIG_fail;
52140 swig_obj[0] = args;
52141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52142 if (!SWIG_IsOK(res1)) {
52143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52144 }
52145 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52146 {
52147 PyThreadState* __tstate = wxPyBeginAllowThreads();
52148 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52149 wxPyEndAllowThreads(__tstate);
52150 if (PyErr_Occurred()) SWIG_fail;
52151 }
52152 resultobj = SWIG_From_int(static_cast< int >(result));
52153 return resultobj;
52154 fail:
52155 return NULL;
52156 }
52157
52158
52159 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52160 PyObject *resultobj = 0;
52161 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52162 int result;
52163 void *argp1 = 0 ;
52164 int res1 = 0 ;
52165 PyObject *swig_obj[1] ;
52166
52167 if (!args) SWIG_fail;
52168 swig_obj[0] = args;
52169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52170 if (!SWIG_IsOK(res1)) {
52171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52172 }
52173 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52174 {
52175 PyThreadState* __tstate = wxPyBeginAllowThreads();
52176 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52177 wxPyEndAllowThreads(__tstate);
52178 if (PyErr_Occurred()) SWIG_fail;
52179 }
52180 resultobj = SWIG_From_int(static_cast< int >(result));
52181 return resultobj;
52182 fail:
52183 return NULL;
52184 }
52185
52186
52187 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52188 PyObject *resultobj = 0;
52189 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52190 int result;
52191 void *argp1 = 0 ;
52192 int res1 = 0 ;
52193 PyObject *swig_obj[1] ;
52194
52195 if (!args) SWIG_fail;
52196 swig_obj[0] = args;
52197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52198 if (!SWIG_IsOK(res1)) {
52199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52200 }
52201 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52202 {
52203 PyThreadState* __tstate = wxPyBeginAllowThreads();
52204 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52205 wxPyEndAllowThreads(__tstate);
52206 if (PyErr_Occurred()) SWIG_fail;
52207 }
52208 resultobj = SWIG_From_int(static_cast< int >(result));
52209 return resultobj;
52210 fail:
52211 return NULL;
52212 }
52213
52214
52215 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52216 PyObject *resultobj = 0;
52217 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52218 bool result;
52219 void *argp1 = 0 ;
52220 int res1 = 0 ;
52221 PyObject *swig_obj[1] ;
52222
52223 if (!args) SWIG_fail;
52224 swig_obj[0] = args;
52225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52226 if (!SWIG_IsOK(res1)) {
52227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52228 }
52229 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52230 {
52231 PyThreadState* __tstate = wxPyBeginAllowThreads();
52232 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52233 wxPyEndAllowThreads(__tstate);
52234 if (PyErr_Occurred()) SWIG_fail;
52235 }
52236 {
52237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52238 }
52239 return resultobj;
52240 fail:
52241 return NULL;
52242 }
52243
52244
52245 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52246 PyObject *resultobj = 0;
52247 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52248 bool arg2 ;
52249 void *argp1 = 0 ;
52250 int res1 = 0 ;
52251 bool val2 ;
52252 int ecode2 = 0 ;
52253 PyObject * obj0 = 0 ;
52254 PyObject * obj1 = 0 ;
52255 char * kwnames[] = {
52256 (char *) "self",(char *) "d", NULL
52257 };
52258
52259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52261 if (!SWIG_IsOK(res1)) {
52262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52263 }
52264 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52265 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52266 if (!SWIG_IsOK(ecode2)) {
52267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52268 }
52269 arg2 = static_cast< bool >(val2);
52270 {
52271 PyThreadState* __tstate = wxPyBeginAllowThreads();
52272 (arg1)->SetDone(arg2);
52273 wxPyEndAllowThreads(__tstate);
52274 if (PyErr_Occurred()) SWIG_fail;
52275 }
52276 resultobj = SWIG_Py_Void();
52277 return resultobj;
52278 fail:
52279 return NULL;
52280 }
52281
52282
52283 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52284 PyObject *resultobj = 0;
52285 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52286 wxRelationship result;
52287 void *argp1 = 0 ;
52288 int res1 = 0 ;
52289 PyObject *swig_obj[1] ;
52290
52291 if (!args) SWIG_fail;
52292 swig_obj[0] = args;
52293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52294 if (!SWIG_IsOK(res1)) {
52295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52296 }
52297 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52298 {
52299 PyThreadState* __tstate = wxPyBeginAllowThreads();
52300 result = (wxRelationship)(arg1)->GetRelationship();
52301 wxPyEndAllowThreads(__tstate);
52302 if (PyErr_Occurred()) SWIG_fail;
52303 }
52304 resultobj = SWIG_From_int(static_cast< int >(result));
52305 return resultobj;
52306 fail:
52307 return NULL;
52308 }
52309
52310
52311 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52312 PyObject *resultobj = 0;
52313 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52314 wxRelationship arg2 ;
52315 void *argp1 = 0 ;
52316 int res1 = 0 ;
52317 int val2 ;
52318 int ecode2 = 0 ;
52319 PyObject * obj0 = 0 ;
52320 PyObject * obj1 = 0 ;
52321 char * kwnames[] = {
52322 (char *) "self",(char *) "r", NULL
52323 };
52324
52325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52327 if (!SWIG_IsOK(res1)) {
52328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52329 }
52330 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52331 ecode2 = SWIG_AsVal_int(obj1, &val2);
52332 if (!SWIG_IsOK(ecode2)) {
52333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52334 }
52335 arg2 = static_cast< wxRelationship >(val2);
52336 {
52337 PyThreadState* __tstate = wxPyBeginAllowThreads();
52338 (arg1)->SetRelationship(arg2);
52339 wxPyEndAllowThreads(__tstate);
52340 if (PyErr_Occurred()) SWIG_fail;
52341 }
52342 resultobj = SWIG_Py_Void();
52343 return resultobj;
52344 fail:
52345 return NULL;
52346 }
52347
52348
52349 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52350 PyObject *resultobj = 0;
52351 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52352 wxWindow *arg2 = (wxWindow *) 0 ;
52353 bool result;
52354 void *argp1 = 0 ;
52355 int res1 = 0 ;
52356 void *argp2 = 0 ;
52357 int res2 = 0 ;
52358 PyObject * obj0 = 0 ;
52359 PyObject * obj1 = 0 ;
52360 char * kwnames[] = {
52361 (char *) "self",(char *) "otherW", NULL
52362 };
52363
52364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52366 if (!SWIG_IsOK(res1)) {
52367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52368 }
52369 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52371 if (!SWIG_IsOK(res2)) {
52372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52373 }
52374 arg2 = reinterpret_cast< wxWindow * >(argp2);
52375 {
52376 PyThreadState* __tstate = wxPyBeginAllowThreads();
52377 result = (bool)(arg1)->ResetIfWin(arg2);
52378 wxPyEndAllowThreads(__tstate);
52379 if (PyErr_Occurred()) SWIG_fail;
52380 }
52381 {
52382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52383 }
52384 return resultobj;
52385 fail:
52386 return NULL;
52387 }
52388
52389
52390 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52391 PyObject *resultobj = 0;
52392 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52393 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52394 wxWindow *arg3 = (wxWindow *) 0 ;
52395 bool result;
52396 void *argp1 = 0 ;
52397 int res1 = 0 ;
52398 void *argp2 = 0 ;
52399 int res2 = 0 ;
52400 void *argp3 = 0 ;
52401 int res3 = 0 ;
52402 PyObject * obj0 = 0 ;
52403 PyObject * obj1 = 0 ;
52404 PyObject * obj2 = 0 ;
52405 char * kwnames[] = {
52406 (char *) "self",(char *) "constraints",(char *) "win", NULL
52407 };
52408
52409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52411 if (!SWIG_IsOK(res1)) {
52412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52413 }
52414 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52416 if (!SWIG_IsOK(res2)) {
52417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52418 }
52419 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52420 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52421 if (!SWIG_IsOK(res3)) {
52422 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52423 }
52424 arg3 = reinterpret_cast< wxWindow * >(argp3);
52425 {
52426 PyThreadState* __tstate = wxPyBeginAllowThreads();
52427 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52428 wxPyEndAllowThreads(__tstate);
52429 if (PyErr_Occurred()) SWIG_fail;
52430 }
52431 {
52432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52433 }
52434 return resultobj;
52435 fail:
52436 return NULL;
52437 }
52438
52439
52440 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52441 PyObject *resultobj = 0;
52442 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52443 wxEdge arg2 ;
52444 wxWindow *arg3 = (wxWindow *) 0 ;
52445 wxWindow *arg4 = (wxWindow *) 0 ;
52446 int result;
52447 void *argp1 = 0 ;
52448 int res1 = 0 ;
52449 int val2 ;
52450 int ecode2 = 0 ;
52451 void *argp3 = 0 ;
52452 int res3 = 0 ;
52453 void *argp4 = 0 ;
52454 int res4 = 0 ;
52455 PyObject * obj0 = 0 ;
52456 PyObject * obj1 = 0 ;
52457 PyObject * obj2 = 0 ;
52458 PyObject * obj3 = 0 ;
52459 char * kwnames[] = {
52460 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52461 };
52462
52463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52465 if (!SWIG_IsOK(res1)) {
52466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52467 }
52468 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52469 ecode2 = SWIG_AsVal_int(obj1, &val2);
52470 if (!SWIG_IsOK(ecode2)) {
52471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52472 }
52473 arg2 = static_cast< wxEdge >(val2);
52474 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52475 if (!SWIG_IsOK(res3)) {
52476 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52477 }
52478 arg3 = reinterpret_cast< wxWindow * >(argp3);
52479 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52480 if (!SWIG_IsOK(res4)) {
52481 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52482 }
52483 arg4 = reinterpret_cast< wxWindow * >(argp4);
52484 {
52485 PyThreadState* __tstate = wxPyBeginAllowThreads();
52486 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52487 wxPyEndAllowThreads(__tstate);
52488 if (PyErr_Occurred()) SWIG_fail;
52489 }
52490 resultobj = SWIG_From_int(static_cast< int >(result));
52491 return resultobj;
52492 fail:
52493 return NULL;
52494 }
52495
52496
52497 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52498 PyObject *obj;
52499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52500 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52501 return SWIG_Py_Void();
52502 }
52503
52504 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52505 PyObject *resultobj = 0;
52506 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52507 wxIndividualLayoutConstraint *result = 0 ;
52508 void *argp1 = 0 ;
52509 int res1 = 0 ;
52510 PyObject *swig_obj[1] ;
52511
52512 if (!args) SWIG_fail;
52513 swig_obj[0] = args;
52514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52515 if (!SWIG_IsOK(res1)) {
52516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52517 }
52518 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52519 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52521 return resultobj;
52522 fail:
52523 return NULL;
52524 }
52525
52526
52527 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52528 PyObject *resultobj = 0;
52529 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52530 wxIndividualLayoutConstraint *result = 0 ;
52531 void *argp1 = 0 ;
52532 int res1 = 0 ;
52533 PyObject *swig_obj[1] ;
52534
52535 if (!args) SWIG_fail;
52536 swig_obj[0] = args;
52537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52538 if (!SWIG_IsOK(res1)) {
52539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52540 }
52541 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52542 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52544 return resultobj;
52545 fail:
52546 return NULL;
52547 }
52548
52549
52550 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52551 PyObject *resultobj = 0;
52552 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52553 wxIndividualLayoutConstraint *result = 0 ;
52554 void *argp1 = 0 ;
52555 int res1 = 0 ;
52556 PyObject *swig_obj[1] ;
52557
52558 if (!args) SWIG_fail;
52559 swig_obj[0] = args;
52560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52561 if (!SWIG_IsOK(res1)) {
52562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52563 }
52564 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52565 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52567 return resultobj;
52568 fail:
52569 return NULL;
52570 }
52571
52572
52573 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52574 PyObject *resultobj = 0;
52575 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52576 wxIndividualLayoutConstraint *result = 0 ;
52577 void *argp1 = 0 ;
52578 int res1 = 0 ;
52579 PyObject *swig_obj[1] ;
52580
52581 if (!args) SWIG_fail;
52582 swig_obj[0] = args;
52583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52584 if (!SWIG_IsOK(res1)) {
52585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52586 }
52587 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52588 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52590 return resultobj;
52591 fail:
52592 return NULL;
52593 }
52594
52595
52596 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52597 PyObject *resultobj = 0;
52598 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52599 wxIndividualLayoutConstraint *result = 0 ;
52600 void *argp1 = 0 ;
52601 int res1 = 0 ;
52602 PyObject *swig_obj[1] ;
52603
52604 if (!args) SWIG_fail;
52605 swig_obj[0] = args;
52606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52607 if (!SWIG_IsOK(res1)) {
52608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52609 }
52610 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52611 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52613 return resultobj;
52614 fail:
52615 return NULL;
52616 }
52617
52618
52619 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52620 PyObject *resultobj = 0;
52621 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52622 wxIndividualLayoutConstraint *result = 0 ;
52623 void *argp1 = 0 ;
52624 int res1 = 0 ;
52625 PyObject *swig_obj[1] ;
52626
52627 if (!args) SWIG_fail;
52628 swig_obj[0] = args;
52629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52630 if (!SWIG_IsOK(res1)) {
52631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52632 }
52633 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52634 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52636 return resultobj;
52637 fail:
52638 return NULL;
52639 }
52640
52641
52642 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52643 PyObject *resultobj = 0;
52644 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52645 wxIndividualLayoutConstraint *result = 0 ;
52646 void *argp1 = 0 ;
52647 int res1 = 0 ;
52648 PyObject *swig_obj[1] ;
52649
52650 if (!args) SWIG_fail;
52651 swig_obj[0] = args;
52652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52653 if (!SWIG_IsOK(res1)) {
52654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52655 }
52656 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52657 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52659 return resultobj;
52660 fail:
52661 return NULL;
52662 }
52663
52664
52665 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52666 PyObject *resultobj = 0;
52667 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52668 wxIndividualLayoutConstraint *result = 0 ;
52669 void *argp1 = 0 ;
52670 int res1 = 0 ;
52671 PyObject *swig_obj[1] ;
52672
52673 if (!args) SWIG_fail;
52674 swig_obj[0] = args;
52675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52676 if (!SWIG_IsOK(res1)) {
52677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52678 }
52679 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52680 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52682 return resultobj;
52683 fail:
52684 return NULL;
52685 }
52686
52687
52688 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52689 PyObject *resultobj = 0;
52690 wxLayoutConstraints *result = 0 ;
52691
52692 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52693 {
52694 PyThreadState* __tstate = wxPyBeginAllowThreads();
52695 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52696 wxPyEndAllowThreads(__tstate);
52697 if (PyErr_Occurred()) SWIG_fail;
52698 }
52699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52700 return resultobj;
52701 fail:
52702 return NULL;
52703 }
52704
52705
52706 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52707 PyObject *resultobj = 0;
52708 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52709 void *argp1 = 0 ;
52710 int res1 = 0 ;
52711 PyObject *swig_obj[1] ;
52712
52713 if (!args) SWIG_fail;
52714 swig_obj[0] = args;
52715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52716 if (!SWIG_IsOK(res1)) {
52717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52718 }
52719 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52720 {
52721 PyThreadState* __tstate = wxPyBeginAllowThreads();
52722 delete arg1;
52723
52724 wxPyEndAllowThreads(__tstate);
52725 if (PyErr_Occurred()) SWIG_fail;
52726 }
52727 resultobj = SWIG_Py_Void();
52728 return resultobj;
52729 fail:
52730 return NULL;
52731 }
52732
52733
52734 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52735 PyObject *resultobj = 0;
52736 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52737 wxWindow *arg2 = (wxWindow *) 0 ;
52738 int *arg3 = (int *) 0 ;
52739 bool result;
52740 void *argp1 = 0 ;
52741 int res1 = 0 ;
52742 void *argp2 = 0 ;
52743 int res2 = 0 ;
52744 int temp3 ;
52745 int res3 = SWIG_TMPOBJ ;
52746 PyObject * obj0 = 0 ;
52747 PyObject * obj1 = 0 ;
52748 char * kwnames[] = {
52749 (char *) "self",(char *) "win", NULL
52750 };
52751
52752 arg3 = &temp3;
52753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52755 if (!SWIG_IsOK(res1)) {
52756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52757 }
52758 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52760 if (!SWIG_IsOK(res2)) {
52761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52762 }
52763 arg2 = reinterpret_cast< wxWindow * >(argp2);
52764 {
52765 PyThreadState* __tstate = wxPyBeginAllowThreads();
52766 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52767 wxPyEndAllowThreads(__tstate);
52768 if (PyErr_Occurred()) SWIG_fail;
52769 }
52770 {
52771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52772 }
52773 if (SWIG_IsTmpObj(res3)) {
52774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52775 } else {
52776 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52778 }
52779 return resultobj;
52780 fail:
52781 return NULL;
52782 }
52783
52784
52785 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52786 PyObject *resultobj = 0;
52787 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52788 bool result;
52789 void *argp1 = 0 ;
52790 int res1 = 0 ;
52791 PyObject *swig_obj[1] ;
52792
52793 if (!args) SWIG_fail;
52794 swig_obj[0] = args;
52795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52796 if (!SWIG_IsOK(res1)) {
52797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52798 }
52799 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52800 {
52801 PyThreadState* __tstate = wxPyBeginAllowThreads();
52802 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52803 wxPyEndAllowThreads(__tstate);
52804 if (PyErr_Occurred()) SWIG_fail;
52805 }
52806 {
52807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52808 }
52809 return resultobj;
52810 fail:
52811 return NULL;
52812 }
52813
52814
52815 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52816 PyObject *obj;
52817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52818 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52819 return SWIG_Py_Void();
52820 }
52821
52822 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52823 return SWIG_Python_InitShadowInstance(args);
52824 }
52825
52826 static PyMethodDef SwigMethods[] = {
52827 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52828 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52829 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52830 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52831 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52832 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52833 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52834 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52835 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52837 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52848 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52849 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52850 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52852 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52853 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52854 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52855 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52856 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52857 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52858 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52860 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52866 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52867 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52868 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52869 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52870 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52871 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52872 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52874 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52882 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52883 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52884 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52889 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52890 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52892 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52894 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52896 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52898 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52900 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52902 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52903 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52905 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52907 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52908 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52909 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52910 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52929 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52930 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52931 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52932 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52933 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52934 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52935 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52936 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52938 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52939 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52940 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52945 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52946 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52947 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52948 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52955 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52962 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52963 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52964 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52965 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52967 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52968 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52969 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52971 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52972 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52973 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52974 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52979 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52980 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52981 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52982 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52983 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52984 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52987 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52988 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52989 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52991 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52992 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52994 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52995 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52996 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52997 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52998 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52999 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53000 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53001 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53002 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53003 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53004 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53009 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53015 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53016 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53017 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53018 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53020 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53023 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53025 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53028 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53030 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53033 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53034 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53035 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53039 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53040 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53041 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53045 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53050 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53051 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53052 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53053 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53054 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53055 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53056 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53063 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53064 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53066 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53067 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53068 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53074 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53075 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53077 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53078 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53079 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53080 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53081 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53082 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53083 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53084 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53086 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53087 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53088 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53089 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53090 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53091 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53092 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53093 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53095 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53104 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53116 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53117 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53132 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53133 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53134 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53135 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53138 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53140 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53142 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53144 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53146 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53149 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53150 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53151 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53152 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53154 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53171 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53172 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53178 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53179 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53180 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53181 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53182 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53183 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53184 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53185 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53186 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53187 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53188 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53189 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53190 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53191 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53192 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53193 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53194 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53195 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53196 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53197 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53198 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53199 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53200 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53201 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53202 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53203 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53204 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53205 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53206 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53207 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53208 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53209 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53210 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53211 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53212 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53214 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53215 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53216 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53217 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53220 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53224 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53228 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53229 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53230 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53231 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53233 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53234 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53236 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53238 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53240 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53242 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53243 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53244 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53246 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53247 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53249 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53250 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53251 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53253 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53254 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53255 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53257 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53259 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53260 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53261 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53263 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53265 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53266 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53268 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53269 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53270 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53272 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53273 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53274 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53275 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53276 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53278 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53279 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53282 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53283 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53285 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53286 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53289 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53290 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53292 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53298 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53299 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53300 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53301 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53302 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53303 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53304 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53305 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53306 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53307 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53308 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53309 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53310 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53311 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53312 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53313 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53314 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53315 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53316 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53317 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53318 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53319 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53320 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53321 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53323 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53324 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53325 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53326 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53327 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53328 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53329 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53330 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53331 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53332 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53333 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53334 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53335 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53336 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53337 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53338 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53339 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53340 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53341 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53342 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53343 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53344 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53345 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53346 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53347 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53348 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53349 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53350 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53351 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53352 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53353 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53354 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53356 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53357 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53359 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53360 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53361 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53362 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53364 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53365 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53366 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53367 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53368 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53369 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53370 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53371 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53372 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53374 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53375 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53376 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53377 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53378 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53379 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53380 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53381 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53382 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53383 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53384 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53385 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53386 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53387 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53388 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53389 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53390 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53391 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53392 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53393 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53394 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53395 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53396 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53397 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53398 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53399 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53400 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53401 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53403 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53404 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53407 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53408 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53409 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53410 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53411 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53412 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53414 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53415 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53418 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53419 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53421 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53422 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53424 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53427 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53428 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53431 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53433 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53434 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53436 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53437 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53438 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53440 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53441 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53442 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53444 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53445 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53447 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53448 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53449 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53450 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53451 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53454 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53456 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53458 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53459 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53460 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53463 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53464 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53465 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53467 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53468 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53469 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53471 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53472 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53473 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53474 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53475 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53476 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53478 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53479 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53480 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53481 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53482 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53483 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53484 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53485 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53491 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53493 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53495 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53496 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53497 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53498 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53499 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53500 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53502 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53503 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53504 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53506 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53507 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53508 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53509 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53510 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53513 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53514 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53515 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53518 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53519 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53520 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53521 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53522 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53524 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53526 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53529 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53531 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53532 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53534 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53535 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53536 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53538 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53539 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53540 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53542 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53544 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53545 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53546 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53548 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53550 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53552 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53553 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53555 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53556 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53558 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53560 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53561 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53562 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53564 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53566 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53567 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53568 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53570 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53572 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53573 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53574 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53575 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53577 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53579 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53581 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53583 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53584 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53586 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53587 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53588 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53589 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53590 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53591 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53592 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53593 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53595 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53597 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53599 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53601 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53603 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53605 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53606 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53607 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53608 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53609 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53610 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53616 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53617 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53618 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53619 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53620 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53621 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53622 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53624 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53626 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53627 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53629 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53630 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53631 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53632 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53634 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53635 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53636 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53637 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53639 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53640 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53642 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53643 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53644 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53646 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53648 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53649 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53650 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53651 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53652 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53654 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53655 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53656 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53657 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53659 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53660 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53661 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53662 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53663 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53664 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53665 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53666 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53667 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53668 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53670 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53673 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53674 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53675 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53677 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53679 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53681 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53683 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53684 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53694 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53695 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53699 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53700 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53701 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53702 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53703 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53704 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53705 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53706 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53707 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53708 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53709 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53710 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53711 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53712 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53713 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53715 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53716 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53719 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53720 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53725 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53726 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53729 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53730 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53731 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53732 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53735 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53736 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53737 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53739 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53741 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53742 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53743 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53745 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53747 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53749 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53752 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53753 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53754 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53755 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53756 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53757 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53761 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53762 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53763 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53764 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53771 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53777 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53778 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53779 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53780 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53781 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53783 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53793 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53794 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53795 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53796 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53799 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53800 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53801 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53802 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53804 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53805 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53809 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53815 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53816 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53817 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53818 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53820 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53821 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53823 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53826 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53828 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53829 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53830 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53839 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53843 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53844 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53846 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53857 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53858 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53859 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53860 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53864 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53867 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53869 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53872 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53874 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53875 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53878 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53880 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53881 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53882 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53883 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53884 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53889 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53890 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53891 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53893 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53894 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53895 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53897 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53899 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53900 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53901 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53903 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53904 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53907 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53915 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53922 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53930 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53933 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53934 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53947 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53949 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53951 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53952 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53954 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53956 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53957 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53959 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53960 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53961 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53965 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53984 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53985 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53987 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53989 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53990 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53991 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53993 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53994 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53997 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53998 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54000 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54001 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54003 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54006 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54007 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54009 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54011 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54013 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54014 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54016 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54017 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54020 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54022 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54024 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54026 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54029 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54031 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54032 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54033 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54035 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54036 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54037 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54039 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54041 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54042 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54044 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54046 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54047 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54051 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54055 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54056 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54058 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54062 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54064 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54066 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54067 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54068 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54069 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54073 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54074 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54075 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54076 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54078 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54079 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54084 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54085 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54086 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54087 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54088 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54090 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54092 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54094 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54095 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54097 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54099 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54102 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54103 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54104 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54106 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54107 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54108 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54122 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54123 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54124 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54125 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54126 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54127 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54133 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54134 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54138 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54139 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54141 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54142 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54144 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54146 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54147 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54149 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54150 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54151 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54157 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54158 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54159 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54160 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54161 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54162 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54169 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54171 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54172 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54173 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54174 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54175 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54176 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54178 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54182 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54183 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54184 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54185 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54186 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54187 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54188 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54190 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54191 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54192 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54198 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54199 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54200 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54202 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54203 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54204 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54210 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54211 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54212 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54213 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54214 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54218 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54219 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54224 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54225 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54227 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54228 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54233 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54235 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54236 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54237 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54238 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54239 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54244 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54245 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54254 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54255 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54256 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54257 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54260 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54262 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54263 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54264 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54265 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54267 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54272 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54273 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54274 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54275 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54276 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54277 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54278 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54279 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54280 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54281 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54282 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54284 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54285 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54286 { NULL, NULL, 0, NULL }
54287 };
54288
54289
54290 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54291
54292 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54293 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54294 }
54295 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54296 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54297 }
54298 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54299 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54300 }
54301 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54302 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54303 }
54304 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54305 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54306 }
54307 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54308 return (void *)((wxSizer *) ((wxGridSizer *) x));
54309 }
54310 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54311 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54312 }
54313 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54314 return (void *)((wxSizer *) ((wxPySizer *) x));
54315 }
54316 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54317 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54318 }
54319 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54320 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54321 }
54322 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54323 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54324 }
54325 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54326 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54327 }
54328 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54329 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54330 }
54331 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54332 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54333 }
54334 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54335 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54336 }
54337 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54338 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54339 }
54340 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54341 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54342 }
54343 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54344 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54345 }
54346 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54347 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54348 }
54349 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54350 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54351 }
54352 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54353 return (void *)((wxEvent *) ((wxPyEvent *) x));
54354 }
54355 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54356 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54357 }
54358 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54359 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54360 }
54361 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54362 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54363 }
54364 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54365 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54366 }
54367 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54368 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54369 }
54370 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54371 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54372 }
54373 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54374 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54375 }
54376 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54377 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54378 }
54379 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54380 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54381 }
54382 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54383 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54384 }
54385 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54386 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54387 }
54388 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54389 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54390 }
54391 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54392 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54393 }
54394 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54395 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54396 }
54397 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54398 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54399 }
54400 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54401 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54402 }
54403 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54404 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54405 }
54406 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54407 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54408 }
54409 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54410 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54411 }
54412 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54413 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54414 }
54415 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54416 return (void *)((wxEvent *) ((wxShowEvent *) x));
54417 }
54418 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54419 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54420 }
54421 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54422 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54423 }
54424 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54425 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54426 }
54427 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54428 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54429 }
54430 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54431 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54432 }
54433 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54434 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54435 }
54436 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54437 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54438 }
54439 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54440 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54441 }
54442 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54443 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54444 }
54445 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54446 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54447 }
54448 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54449 return (void *)((wxControl *) ((wxControlWithItems *) x));
54450 }
54451 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54452 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54453 }
54454 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54455 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54456 }
54457 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54458 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54459 }
54460 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54461 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54462 }
54463 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54464 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54465 }
54466 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54467 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54468 }
54469 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54470 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54471 }
54472 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54473 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54474 }
54475 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54476 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54477 }
54478 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54479 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54480 }
54481 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54482 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54483 }
54484 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54485 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54486 }
54487 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54488 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54489 }
54490 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54491 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54492 }
54493 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54494 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54495 }
54496 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54497 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54498 }
54499 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54500 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54501 }
54502 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54503 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54504 }
54505 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54506 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54507 }
54508 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54509 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54510 }
54511 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54512 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54513 }
54514 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54515 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54516 }
54517 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54518 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54519 }
54520 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54521 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54522 }
54523 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54524 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54525 }
54526 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54527 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54528 }
54529 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54530 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54531 }
54532 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54533 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54534 }
54535 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54536 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54537 }
54538 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54539 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54540 }
54541 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54542 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54543 }
54544 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54545 return (void *)((wxObject *) ((wxSizerItem *) x));
54546 }
54547 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54548 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54549 }
54550 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54551 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54552 }
54553 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54554 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54555 }
54556 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54558 }
54559 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54561 }
54562 static void *_p_wxSizerTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) ((wxSizer *) x));
54564 }
54565 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54567 }
54568 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54570 }
54571 static void *_p_wxEventTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) ((wxEvent *) x));
54573 }
54574 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54576 }
54577 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54579 }
54580 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54582 }
54583 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54585 }
54586 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54588 }
54589 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54591 }
54592 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54594 }
54595 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54597 }
54598 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54600 }
54601 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54603 }
54604 static void *_p_wxControlTo_p_wxObject(void *x) {
54605 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54606 }
54607 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54608 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54609 }
54610 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54611 return (void *)((wxObject *) ((wxFSFile *) x));
54612 }
54613 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54614 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54615 }
54616 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54617 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54618 }
54619 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54620 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54621 }
54622 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54623 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54624 }
54625 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54626 return (void *)((wxObject *) ((wxMenuItem *) x));
54627 }
54628 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54629 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54630 }
54631 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54632 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54633 }
54634 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54635 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54636 }
54637 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54638 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54639 }
54640 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54641 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54642 }
54643 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54644 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54645 }
54646 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54647 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54648 }
54649 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54650 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54651 }
54652 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54653 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54654 }
54655 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54656 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54657 }
54658 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54659 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54660 }
54661 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54662 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54663 }
54664 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54665 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54666 }
54667 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54668 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54669 }
54670 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54671 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54672 }
54673 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54674 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54675 }
54676 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54677 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54678 }
54679 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54680 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54681 }
54682 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54683 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54684 }
54685 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54686 return (void *)((wxObject *) ((wxImageHandler *) x));
54687 }
54688 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54689 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54690 }
54691 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54692 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54693 }
54694 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54695 return (void *)((wxObject *) ((wxEvtHandler *) x));
54696 }
54697 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54698 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54699 }
54700 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54701 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54702 }
54703 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54704 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54705 }
54706 static void *_p_wxImageTo_p_wxObject(void *x) {
54707 return (void *)((wxObject *) ((wxImage *) x));
54708 }
54709 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54710 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54711 }
54712 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54713 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54714 }
54715 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54716 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54717 }
54718 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54719 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54720 }
54721 static void *_p_wxWindowTo_p_wxObject(void *x) {
54722 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54723 }
54724 static void *_p_wxMenuTo_p_wxObject(void *x) {
54725 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54726 }
54727 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54728 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54729 }
54730 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54731 return (void *)((wxObject *) ((wxFileSystem *) x));
54732 }
54733 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54734 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54735 }
54736 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54737 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54738 }
54739 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54740 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54741 }
54742 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54743 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54744 }
54745 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54746 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54747 }
54748 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54749 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54750 }
54751 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54752 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54753 }
54754 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54755 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54756 }
54757 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54758 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54759 }
54760 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54761 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54762 }
54763 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54764 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54765 }
54766 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54767 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54768 }
54769 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54770 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54771 }
54772 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54773 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54774 }
54775 static void *_p_wxControlTo_p_wxWindow(void *x) {
54776 return (void *)((wxWindow *) ((wxControl *) x));
54777 }
54778 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54779 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54780 }
54781 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54782 return (void *)((wxWindow *) ((wxMenuBar *) x));
54783 }
54784 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54785 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54786 }
54787 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54788 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54789 }
54790 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54791 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54792 }
54793 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54794 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54795 }
54796 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54797 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54798 }
54799 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54800 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54801 }
54802 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54803 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54804 }
54805 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54806 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54807 }
54808 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54809 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54810 }
54811 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54812 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54813 }
54814 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54815 return (void *)((wxValidator *) ((wxPyValidator *) x));
54816 }
54817 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54819 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};
54820 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54923 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54924 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54925 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54926 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54927 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54928 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54929 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54930 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54931 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54932 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54933 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54934 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54935 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54936 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54937 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54938 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54939 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54940 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54941 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54942 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54943 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54944 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54945 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54946 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54947 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54948 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54949
54950 static swig_type_info *swig_type_initial[] = {
54951 &_swigt__p_buffer,
54952 &_swigt__p_char,
54953 &_swigt__p_form_ops_t,
54954 &_swigt__p_int,
54955 &_swigt__p_long,
54956 &_swigt__p_unsigned_char,
54957 &_swigt__p_unsigned_int,
54958 &_swigt__p_unsigned_long,
54959 &_swigt__p_wxANIHandler,
54960 &_swigt__p_wxAcceleratorEntry,
54961 &_swigt__p_wxAcceleratorTable,
54962 &_swigt__p_wxActivateEvent,
54963 &_swigt__p_wxAppTraits,
54964 &_swigt__p_wxArrayString,
54965 &_swigt__p_wxBMPHandler,
54966 &_swigt__p_wxBitmap,
54967 &_swigt__p_wxBoxSizer,
54968 &_swigt__p_wxButton,
54969 &_swigt__p_wxCURHandler,
54970 &_swigt__p_wxCaret,
54971 &_swigt__p_wxChildFocusEvent,
54972 &_swigt__p_wxClipboardTextEvent,
54973 &_swigt__p_wxCloseEvent,
54974 &_swigt__p_wxColour,
54975 &_swigt__p_wxCommandEvent,
54976 &_swigt__p_wxContextMenuEvent,
54977 &_swigt__p_wxControl,
54978 &_swigt__p_wxControlWithItems,
54979 &_swigt__p_wxCursor,
54980 &_swigt__p_wxDC,
54981 &_swigt__p_wxDateEvent,
54982 &_swigt__p_wxDateTime,
54983 &_swigt__p_wxDisplayChangedEvent,
54984 &_swigt__p_wxDropFilesEvent,
54985 &_swigt__p_wxDuplexMode,
54986 &_swigt__p_wxEraseEvent,
54987 &_swigt__p_wxEvent,
54988 &_swigt__p_wxEventLoop,
54989 &_swigt__p_wxEventLoopActivator,
54990 &_swigt__p_wxEvtHandler,
54991 &_swigt__p_wxFSFile,
54992 &_swigt__p_wxFileSystem,
54993 &_swigt__p_wxFileSystemHandler,
54994 &_swigt__p_wxFlexGridSizer,
54995 &_swigt__p_wxFocusEvent,
54996 &_swigt__p_wxFont,
54997 &_swigt__p_wxFrame,
54998 &_swigt__p_wxGBPosition,
54999 &_swigt__p_wxGBSizerItem,
55000 &_swigt__p_wxGBSpan,
55001 &_swigt__p_wxGIFHandler,
55002 &_swigt__p_wxGridBagSizer,
55003 &_swigt__p_wxGridSizer,
55004 &_swigt__p_wxHelpEvent__Origin,
55005 &_swigt__p_wxICOHandler,
55006 &_swigt__p_wxIconizeEvent,
55007 &_swigt__p_wxIdleEvent,
55008 &_swigt__p_wxImage,
55009 &_swigt__p_wxImageHandler,
55010 &_swigt__p_wxImageHistogram,
55011 &_swigt__p_wxImage_HSVValue,
55012 &_swigt__p_wxImage_RGBValue,
55013 &_swigt__p_wxIndividualLayoutConstraint,
55014 &_swigt__p_wxInitDialogEvent,
55015 &_swigt__p_wxInputStream,
55016 &_swigt__p_wxInternetFSHandler,
55017 &_swigt__p_wxItemContainer,
55018 &_swigt__p_wxJPEGHandler,
55019 &_swigt__p_wxKeyEvent,
55020 &_swigt__p_wxLayoutConstraints,
55021 &_swigt__p_wxMaximizeEvent,
55022 &_swigt__p_wxMemoryFSHandler,
55023 &_swigt__p_wxMenu,
55024 &_swigt__p_wxMenuBar,
55025 &_swigt__p_wxMenuBarBase,
55026 &_swigt__p_wxMenuEvent,
55027 &_swigt__p_wxMenuItem,
55028 &_swigt__p_wxMouseCaptureChangedEvent,
55029 &_swigt__p_wxMouseCaptureLostEvent,
55030 &_swigt__p_wxMouseEvent,
55031 &_swigt__p_wxMoveEvent,
55032 &_swigt__p_wxNavigationKeyEvent,
55033 &_swigt__p_wxNcPaintEvent,
55034 &_swigt__p_wxNotifyEvent,
55035 &_swigt__p_wxObject,
55036 &_swigt__p_wxOutputStream,
55037 &_swigt__p_wxPCXHandler,
55038 &_swigt__p_wxPNGHandler,
55039 &_swigt__p_wxPNMHandler,
55040 &_swigt__p_wxPaintEvent,
55041 &_swigt__p_wxPaletteChangedEvent,
55042 &_swigt__p_wxPaperSize,
55043 &_swigt__p_wxPoint,
55044 &_swigt__p_wxPoint2D,
55045 &_swigt__p_wxPropagateOnce,
55046 &_swigt__p_wxPropagationDisabler,
55047 &_swigt__p_wxPyApp,
55048 &_swigt__p_wxPyCommandEvent,
55049 &_swigt__p_wxPyDropTarget,
55050 &_swigt__p_wxPyEvent,
55051 &_swigt__p_wxPyFileSystemHandler,
55052 &_swigt__p_wxPyImageHandler,
55053 &_swigt__p_wxPyInputStream,
55054 &_swigt__p_wxPySizer,
55055 &_swigt__p_wxPyValidator,
55056 &_swigt__p_wxQuantize,
55057 &_swigt__p_wxQueryNewPaletteEvent,
55058 &_swigt__p_wxRealPoint,
55059 &_swigt__p_wxRect,
55060 &_swigt__p_wxRegion,
55061 &_swigt__p_wxScrollEvent,
55062 &_swigt__p_wxScrollWinEvent,
55063 &_swigt__p_wxSetCursorEvent,
55064 &_swigt__p_wxShowEvent,
55065 &_swigt__p_wxSize,
55066 &_swigt__p_wxSizeEvent,
55067 &_swigt__p_wxSizer,
55068 &_swigt__p_wxSizerItem,
55069 &_swigt__p_wxStaticBox,
55070 &_swigt__p_wxStaticBoxSizer,
55071 &_swigt__p_wxStdDialogButtonSizer,
55072 &_swigt__p_wxSysColourChangedEvent,
55073 &_swigt__p_wxTIFFHandler,
55074 &_swigt__p_wxToolTip,
55075 &_swigt__p_wxUpdateUIEvent,
55076 &_swigt__p_wxValidator,
55077 &_swigt__p_wxVisualAttributes,
55078 &_swigt__p_wxWindow,
55079 &_swigt__p_wxWindowCreateEvent,
55080 &_swigt__p_wxWindowDestroyEvent,
55081 &_swigt__p_wxXPMHandler,
55082 &_swigt__p_wxZipFSHandler,
55083 };
55084
55085 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55099 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}};
55100 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55101 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}};
55102 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55103 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}};
55104 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55109 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}};
55110 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55111 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}};
55112 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55113 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55121 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}};
55122 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55124 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}};
55125 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55126 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55127 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}};
55128 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}};
55129 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55130 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55135 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55137 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}};
55138 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55139 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}};
55140 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55143 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}};
55144 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55145 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55151 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}};
55152 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55153 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55154 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55169 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}};
55170 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55171 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55172 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55175 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55176 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55183 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55184 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55185 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55186 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55191 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55192 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55193 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55194 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55195 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55196 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55197 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55198 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55199 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55200 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55201 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}};
55202 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}};
55203 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55204 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55205 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55206 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55207 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55208 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55209 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55210 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}};
55211 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55212 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}};
55213 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55214 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55215 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55216 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55217
55218 static swig_cast_info *swig_cast_initial[] = {
55219 _swigc__p_buffer,
55220 _swigc__p_char,
55221 _swigc__p_form_ops_t,
55222 _swigc__p_int,
55223 _swigc__p_long,
55224 _swigc__p_unsigned_char,
55225 _swigc__p_unsigned_int,
55226 _swigc__p_unsigned_long,
55227 _swigc__p_wxANIHandler,
55228 _swigc__p_wxAcceleratorEntry,
55229 _swigc__p_wxAcceleratorTable,
55230 _swigc__p_wxActivateEvent,
55231 _swigc__p_wxAppTraits,
55232 _swigc__p_wxArrayString,
55233 _swigc__p_wxBMPHandler,
55234 _swigc__p_wxBitmap,
55235 _swigc__p_wxBoxSizer,
55236 _swigc__p_wxButton,
55237 _swigc__p_wxCURHandler,
55238 _swigc__p_wxCaret,
55239 _swigc__p_wxChildFocusEvent,
55240 _swigc__p_wxClipboardTextEvent,
55241 _swigc__p_wxCloseEvent,
55242 _swigc__p_wxColour,
55243 _swigc__p_wxCommandEvent,
55244 _swigc__p_wxContextMenuEvent,
55245 _swigc__p_wxControl,
55246 _swigc__p_wxControlWithItems,
55247 _swigc__p_wxCursor,
55248 _swigc__p_wxDC,
55249 _swigc__p_wxDateEvent,
55250 _swigc__p_wxDateTime,
55251 _swigc__p_wxDisplayChangedEvent,
55252 _swigc__p_wxDropFilesEvent,
55253 _swigc__p_wxDuplexMode,
55254 _swigc__p_wxEraseEvent,
55255 _swigc__p_wxEvent,
55256 _swigc__p_wxEventLoop,
55257 _swigc__p_wxEventLoopActivator,
55258 _swigc__p_wxEvtHandler,
55259 _swigc__p_wxFSFile,
55260 _swigc__p_wxFileSystem,
55261 _swigc__p_wxFileSystemHandler,
55262 _swigc__p_wxFlexGridSizer,
55263 _swigc__p_wxFocusEvent,
55264 _swigc__p_wxFont,
55265 _swigc__p_wxFrame,
55266 _swigc__p_wxGBPosition,
55267 _swigc__p_wxGBSizerItem,
55268 _swigc__p_wxGBSpan,
55269 _swigc__p_wxGIFHandler,
55270 _swigc__p_wxGridBagSizer,
55271 _swigc__p_wxGridSizer,
55272 _swigc__p_wxHelpEvent__Origin,
55273 _swigc__p_wxICOHandler,
55274 _swigc__p_wxIconizeEvent,
55275 _swigc__p_wxIdleEvent,
55276 _swigc__p_wxImage,
55277 _swigc__p_wxImageHandler,
55278 _swigc__p_wxImageHistogram,
55279 _swigc__p_wxImage_HSVValue,
55280 _swigc__p_wxImage_RGBValue,
55281 _swigc__p_wxIndividualLayoutConstraint,
55282 _swigc__p_wxInitDialogEvent,
55283 _swigc__p_wxInputStream,
55284 _swigc__p_wxInternetFSHandler,
55285 _swigc__p_wxItemContainer,
55286 _swigc__p_wxJPEGHandler,
55287 _swigc__p_wxKeyEvent,
55288 _swigc__p_wxLayoutConstraints,
55289 _swigc__p_wxMaximizeEvent,
55290 _swigc__p_wxMemoryFSHandler,
55291 _swigc__p_wxMenu,
55292 _swigc__p_wxMenuBar,
55293 _swigc__p_wxMenuBarBase,
55294 _swigc__p_wxMenuEvent,
55295 _swigc__p_wxMenuItem,
55296 _swigc__p_wxMouseCaptureChangedEvent,
55297 _swigc__p_wxMouseCaptureLostEvent,
55298 _swigc__p_wxMouseEvent,
55299 _swigc__p_wxMoveEvent,
55300 _swigc__p_wxNavigationKeyEvent,
55301 _swigc__p_wxNcPaintEvent,
55302 _swigc__p_wxNotifyEvent,
55303 _swigc__p_wxObject,
55304 _swigc__p_wxOutputStream,
55305 _swigc__p_wxPCXHandler,
55306 _swigc__p_wxPNGHandler,
55307 _swigc__p_wxPNMHandler,
55308 _swigc__p_wxPaintEvent,
55309 _swigc__p_wxPaletteChangedEvent,
55310 _swigc__p_wxPaperSize,
55311 _swigc__p_wxPoint,
55312 _swigc__p_wxPoint2D,
55313 _swigc__p_wxPropagateOnce,
55314 _swigc__p_wxPropagationDisabler,
55315 _swigc__p_wxPyApp,
55316 _swigc__p_wxPyCommandEvent,
55317 _swigc__p_wxPyDropTarget,
55318 _swigc__p_wxPyEvent,
55319 _swigc__p_wxPyFileSystemHandler,
55320 _swigc__p_wxPyImageHandler,
55321 _swigc__p_wxPyInputStream,
55322 _swigc__p_wxPySizer,
55323 _swigc__p_wxPyValidator,
55324 _swigc__p_wxQuantize,
55325 _swigc__p_wxQueryNewPaletteEvent,
55326 _swigc__p_wxRealPoint,
55327 _swigc__p_wxRect,
55328 _swigc__p_wxRegion,
55329 _swigc__p_wxScrollEvent,
55330 _swigc__p_wxScrollWinEvent,
55331 _swigc__p_wxSetCursorEvent,
55332 _swigc__p_wxShowEvent,
55333 _swigc__p_wxSize,
55334 _swigc__p_wxSizeEvent,
55335 _swigc__p_wxSizer,
55336 _swigc__p_wxSizerItem,
55337 _swigc__p_wxStaticBox,
55338 _swigc__p_wxStaticBoxSizer,
55339 _swigc__p_wxStdDialogButtonSizer,
55340 _swigc__p_wxSysColourChangedEvent,
55341 _swigc__p_wxTIFFHandler,
55342 _swigc__p_wxToolTip,
55343 _swigc__p_wxUpdateUIEvent,
55344 _swigc__p_wxValidator,
55345 _swigc__p_wxVisualAttributes,
55346 _swigc__p_wxWindow,
55347 _swigc__p_wxWindowCreateEvent,
55348 _swigc__p_wxWindowDestroyEvent,
55349 _swigc__p_wxXPMHandler,
55350 _swigc__p_wxZipFSHandler,
55351 };
55352
55353
55354 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55355
55356 static swig_const_info swig_const_table[] = {
55357 {0, 0, 0, 0.0, 0, 0}};
55358
55359 #ifdef __cplusplus
55360 }
55361 #endif
55362 /* -----------------------------------------------------------------------------
55363 * Type initialization:
55364 * This problem is tough by the requirement that no dynamic
55365 * memory is used. Also, since swig_type_info structures store pointers to
55366 * swig_cast_info structures and swig_cast_info structures store pointers back
55367 * to swig_type_info structures, we need some lookup code at initialization.
55368 * The idea is that swig generates all the structures that are needed.
55369 * The runtime then collects these partially filled structures.
55370 * The SWIG_InitializeModule function takes these initial arrays out of
55371 * swig_module, and does all the lookup, filling in the swig_module.types
55372 * array with the correct data and linking the correct swig_cast_info
55373 * structures together.
55374 *
55375 * The generated swig_type_info structures are assigned staticly to an initial
55376 * array. We just loop though that array, and handle each type individually.
55377 * First we lookup if this type has been already loaded, and if so, use the
55378 * loaded structure instead of the generated one. Then we have to fill in the
55379 * cast linked list. The cast data is initially stored in something like a
55380 * two-dimensional array. Each row corresponds to a type (there are the same
55381 * number of rows as there are in the swig_type_initial array). Each entry in
55382 * a column is one of the swig_cast_info structures for that type.
55383 * The cast_initial array is actually an array of arrays, because each row has
55384 * a variable number of columns. So to actually build the cast linked list,
55385 * we find the array of casts associated with the type, and loop through it
55386 * adding the casts to the list. The one last trick we need to do is making
55387 * sure the type pointer in the swig_cast_info struct is correct.
55388 *
55389 * First off, we lookup the cast->type name to see if it is already loaded.
55390 * There are three cases to handle:
55391 * 1) If the cast->type has already been loaded AND the type we are adding
55392 * casting info to has not been loaded (it is in this module), THEN we
55393 * replace the cast->type pointer with the type pointer that has already
55394 * been loaded.
55395 * 2) If BOTH types (the one we are adding casting info to, and the
55396 * cast->type) are loaded, THEN the cast info has already been loaded by
55397 * the previous module so we just ignore it.
55398 * 3) Finally, if cast->type has not already been loaded, then we add that
55399 * swig_cast_info to the linked list (because the cast->type) pointer will
55400 * be correct.
55401 * ----------------------------------------------------------------------------- */
55402
55403 #ifdef __cplusplus
55404 extern "C" {
55405 #if 0
55406 } /* c-mode */
55407 #endif
55408 #endif
55409
55410 #if 0
55411 #define SWIGRUNTIME_DEBUG
55412 #endif
55413
55414 SWIGRUNTIME void
55415 SWIG_InitializeModule(void *clientdata) {
55416 size_t i;
55417 swig_module_info *module_head;
55418 static int init_run = 0;
55419
55420 clientdata = clientdata;
55421
55422 if (init_run) return;
55423 init_run = 1;
55424
55425 /* Initialize the swig_module */
55426 swig_module.type_initial = swig_type_initial;
55427 swig_module.cast_initial = swig_cast_initial;
55428
55429 /* Try and load any already created modules */
55430 module_head = SWIG_GetModule(clientdata);
55431 if (module_head) {
55432 swig_module.next = module_head->next;
55433 module_head->next = &swig_module;
55434 } else {
55435 /* This is the first module loaded */
55436 swig_module.next = &swig_module;
55437 SWIG_SetModule(clientdata, &swig_module);
55438 }
55439
55440 /* Now work on filling in swig_module.types */
55441 #ifdef SWIGRUNTIME_DEBUG
55442 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55443 #endif
55444 for (i = 0; i < swig_module.size; ++i) {
55445 swig_type_info *type = 0;
55446 swig_type_info *ret;
55447 swig_cast_info *cast;
55448
55449 #ifdef SWIGRUNTIME_DEBUG
55450 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55451 #endif
55452
55453 /* if there is another module already loaded */
55454 if (swig_module.next != &swig_module) {
55455 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55456 }
55457 if (type) {
55458 /* Overwrite clientdata field */
55459 #ifdef SWIGRUNTIME_DEBUG
55460 printf("SWIG_InitializeModule: found type %s\n", type->name);
55461 #endif
55462 if (swig_module.type_initial[i]->clientdata) {
55463 type->clientdata = swig_module.type_initial[i]->clientdata;
55464 #ifdef SWIGRUNTIME_DEBUG
55465 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55466 #endif
55467 }
55468 } else {
55469 type = swig_module.type_initial[i];
55470 }
55471
55472 /* Insert casting types */
55473 cast = swig_module.cast_initial[i];
55474 while (cast->type) {
55475 /* Don't need to add information already in the list */
55476 ret = 0;
55477 #ifdef SWIGRUNTIME_DEBUG
55478 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55479 #endif
55480 if (swig_module.next != &swig_module) {
55481 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55482 #ifdef SWIGRUNTIME_DEBUG
55483 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55484 #endif
55485 }
55486 if (ret) {
55487 if (type == swig_module.type_initial[i]) {
55488 #ifdef SWIGRUNTIME_DEBUG
55489 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55490 #endif
55491 cast->type = ret;
55492 ret = 0;
55493 } else {
55494 /* Check for casting already in the list */
55495 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55496 #ifdef SWIGRUNTIME_DEBUG
55497 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55498 #endif
55499 if (!ocast) ret = 0;
55500 }
55501 }
55502
55503 if (!ret) {
55504 #ifdef SWIGRUNTIME_DEBUG
55505 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55506 #endif
55507 if (type->cast) {
55508 type->cast->prev = cast;
55509 cast->next = type->cast;
55510 }
55511 type->cast = cast;
55512 }
55513 cast++;
55514 }
55515 /* Set entry in modules->types array equal to the type */
55516 swig_module.types[i] = type;
55517 }
55518 swig_module.types[i] = 0;
55519
55520 #ifdef SWIGRUNTIME_DEBUG
55521 printf("**** SWIG_InitializeModule: Cast List ******\n");
55522 for (i = 0; i < swig_module.size; ++i) {
55523 int j = 0;
55524 swig_cast_info *cast = swig_module.cast_initial[i];
55525 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55526 while (cast->type) {
55527 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55528 cast++;
55529 ++j;
55530 }
55531 printf("---- Total casts: %d\n",j);
55532 }
55533 printf("**** SWIG_InitializeModule: Cast List ******\n");
55534 #endif
55535 }
55536
55537 /* This function will propagate the clientdata field of type to
55538 * any new swig_type_info structures that have been added into the list
55539 * of equivalent types. It is like calling
55540 * SWIG_TypeClientData(type, clientdata) a second time.
55541 */
55542 SWIGRUNTIME void
55543 SWIG_PropagateClientData(void) {
55544 size_t i;
55545 swig_cast_info *equiv;
55546 static int init_run = 0;
55547
55548 if (init_run) return;
55549 init_run = 1;
55550
55551 for (i = 0; i < swig_module.size; i++) {
55552 if (swig_module.types[i]->clientdata) {
55553 equiv = swig_module.types[i]->cast;
55554 while (equiv) {
55555 if (!equiv->converter) {
55556 if (equiv->type && !equiv->type->clientdata)
55557 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55558 }
55559 equiv = equiv->next;
55560 }
55561 }
55562 }
55563 }
55564
55565 #ifdef __cplusplus
55566 #if 0
55567 {
55568 /* c-mode */
55569 #endif
55570 }
55571 #endif
55572
55573
55574
55575 #ifdef __cplusplus
55576 extern "C" {
55577 #endif
55578
55579 /* Python-specific SWIG API */
55580 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55581 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55582 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55583
55584 /* -----------------------------------------------------------------------------
55585 * global variable support code.
55586 * ----------------------------------------------------------------------------- */
55587
55588 typedef struct swig_globalvar {
55589 char *name; /* Name of global variable */
55590 PyObject *(*get_attr)(void); /* Return the current value */
55591 int (*set_attr)(PyObject *); /* Set the value */
55592 struct swig_globalvar *next;
55593 } swig_globalvar;
55594
55595 typedef struct swig_varlinkobject {
55596 PyObject_HEAD
55597 swig_globalvar *vars;
55598 } swig_varlinkobject;
55599
55600 SWIGINTERN PyObject *
55601 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55602 return PyString_FromString("<Swig global variables>");
55603 }
55604
55605 SWIGINTERN PyObject *
55606 swig_varlink_str(swig_varlinkobject *v) {
55607 PyObject *str = PyString_FromString("(");
55608 swig_globalvar *var;
55609 for (var = v->vars; var; var=var->next) {
55610 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55611 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55612 }
55613 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55614 return str;
55615 }
55616
55617 SWIGINTERN int
55618 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55619 PyObject *str = swig_varlink_str(v);
55620 fprintf(fp,"Swig global variables ");
55621 fprintf(fp,"%s\n", PyString_AsString(str));
55622 Py_DECREF(str);
55623 return 0;
55624 }
55625
55626 SWIGINTERN void
55627 swig_varlink_dealloc(swig_varlinkobject *v) {
55628 swig_globalvar *var = v->vars;
55629 while (var) {
55630 swig_globalvar *n = var->next;
55631 free(var->name);
55632 free(var);
55633 var = n;
55634 }
55635 }
55636
55637 SWIGINTERN PyObject *
55638 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55639 PyObject *res = NULL;
55640 swig_globalvar *var = v->vars;
55641 while (var) {
55642 if (strcmp(var->name,n) == 0) {
55643 res = (*var->get_attr)();
55644 break;
55645 }
55646 var = var->next;
55647 }
55648 if (res == NULL && !PyErr_Occurred()) {
55649 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55650 }
55651 return res;
55652 }
55653
55654 SWIGINTERN int
55655 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55656 int res = 1;
55657 swig_globalvar *var = v->vars;
55658 while (var) {
55659 if (strcmp(var->name,n) == 0) {
55660 res = (*var->set_attr)(p);
55661 break;
55662 }
55663 var = var->next;
55664 }
55665 if (res == 1 && !PyErr_Occurred()) {
55666 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55667 }
55668 return res;
55669 }
55670
55671 SWIGINTERN PyTypeObject*
55672 swig_varlink_type(void) {
55673 static char varlink__doc__[] = "Swig var link object";
55674 static PyTypeObject varlink_type;
55675 static int type_init = 0;
55676 if (!type_init) {
55677 const PyTypeObject tmp
55678 = {
55679 PyObject_HEAD_INIT(NULL)
55680 0, /* Number of items in variable part (ob_size) */
55681 (char *)"swigvarlink", /* Type name (tp_name) */
55682 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55683 0, /* Itemsize (tp_itemsize) */
55684 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55685 (printfunc) swig_varlink_print, /* Print (tp_print) */
55686 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55687 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55688 0, /* tp_compare */
55689 (reprfunc) swig_varlink_repr, /* tp_repr */
55690 0, /* tp_as_number */
55691 0, /* tp_as_sequence */
55692 0, /* tp_as_mapping */
55693 0, /* tp_hash */
55694 0, /* tp_call */
55695 (reprfunc)swig_varlink_str, /* tp_str */
55696 0, /* tp_getattro */
55697 0, /* tp_setattro */
55698 0, /* tp_as_buffer */
55699 0, /* tp_flags */
55700 varlink__doc__, /* tp_doc */
55701 0, /* tp_traverse */
55702 0, /* tp_clear */
55703 0, /* tp_richcompare */
55704 0, /* tp_weaklistoffset */
55705 #if PY_VERSION_HEX >= 0x02020000
55706 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55707 #endif
55708 #if PY_VERSION_HEX >= 0x02030000
55709 0, /* tp_del */
55710 #endif
55711 #ifdef COUNT_ALLOCS
55712 0,0,0,0 /* tp_alloc -> tp_next */
55713 #endif
55714 };
55715 varlink_type = tmp;
55716 varlink_type.ob_type = &PyType_Type;
55717 type_init = 1;
55718 }
55719 return &varlink_type;
55720 }
55721
55722 /* Create a variable linking object for use later */
55723 SWIGINTERN PyObject *
55724 SWIG_Python_newvarlink(void) {
55725 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55726 if (result) {
55727 result->vars = 0;
55728 }
55729 return ((PyObject*) result);
55730 }
55731
55732 SWIGINTERN void
55733 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55734 swig_varlinkobject *v = (swig_varlinkobject *) p;
55735 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55736 if (gv) {
55737 size_t size = strlen(name)+1;
55738 gv->name = (char *)malloc(size);
55739 if (gv->name) {
55740 strncpy(gv->name,name,size);
55741 gv->get_attr = get_attr;
55742 gv->set_attr = set_attr;
55743 gv->next = v->vars;
55744 }
55745 }
55746 v->vars = gv;
55747 }
55748
55749 SWIGINTERN PyObject *
55750 SWIG_globals() {
55751 static PyObject *_SWIG_globals = 0;
55752 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55753 return _SWIG_globals;
55754 }
55755
55756 /* -----------------------------------------------------------------------------
55757 * constants/methods manipulation
55758 * ----------------------------------------------------------------------------- */
55759
55760 /* Install Constants */
55761 SWIGINTERN void
55762 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55763 PyObject *obj = 0;
55764 size_t i;
55765 for (i = 0; constants[i].type; ++i) {
55766 switch(constants[i].type) {
55767 case SWIG_PY_POINTER:
55768 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55769 break;
55770 case SWIG_PY_BINARY:
55771 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55772 break;
55773 default:
55774 obj = 0;
55775 break;
55776 }
55777 if (obj) {
55778 PyDict_SetItemString(d, constants[i].name, obj);
55779 Py_DECREF(obj);
55780 }
55781 }
55782 }
55783
55784 /* -----------------------------------------------------------------------------*/
55785 /* Fix SwigMethods to carry the callback ptrs when needed */
55786 /* -----------------------------------------------------------------------------*/
55787
55788 SWIGINTERN void
55789 SWIG_Python_FixMethods(PyMethodDef *methods,
55790 swig_const_info *const_table,
55791 swig_type_info **types,
55792 swig_type_info **types_initial) {
55793 size_t i;
55794 for (i = 0; methods[i].ml_name; ++i) {
55795 const char *c = methods[i].ml_doc;
55796 if (c && (c = strstr(c, "swig_ptr: "))) {
55797 int j;
55798 swig_const_info *ci = 0;
55799 const char *name = c + 10;
55800 for (j = 0; const_table[j].type; ++j) {
55801 if (strncmp(const_table[j].name, name,
55802 strlen(const_table[j].name)) == 0) {
55803 ci = &(const_table[j]);
55804 break;
55805 }
55806 }
55807 if (ci) {
55808 size_t shift = (ci->ptype) - types;
55809 swig_type_info *ty = types_initial[shift];
55810 size_t ldoc = (c - methods[i].ml_doc);
55811 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55812 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55813 if (ndoc) {
55814 char *buff = ndoc;
55815 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55816 if (ptr) {
55817 strncpy(buff, methods[i].ml_doc, ldoc);
55818 buff += ldoc;
55819 strncpy(buff, "swig_ptr: ", 10);
55820 buff += 10;
55821 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55822 methods[i].ml_doc = ndoc;
55823 }
55824 }
55825 }
55826 }
55827 }
55828 }
55829
55830 #ifdef __cplusplus
55831 }
55832 #endif
55833
55834 /* -----------------------------------------------------------------------------*
55835 * Partial Init method
55836 * -----------------------------------------------------------------------------*/
55837
55838 #ifdef __cplusplus
55839 extern "C"
55840 #endif
55841 SWIGEXPORT void SWIG_init(void) {
55842 PyObject *m, *d;
55843
55844 /* Fix SwigMethods to carry the callback ptrs when needed */
55845 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55846
55847 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55848 d = PyModule_GetDict(m);
55849
55850 SWIG_InitializeModule(0);
55851 SWIG_InstallConstants(d,swig_const_table);
55852
55853
55854
55855 #ifndef wxPyUSE_EXPORT
55856 // Make our API structure a CObject so other modules can import it
55857 // from this module.
55858 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55859 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55860 Py_XDECREF(cobj);
55861 #endif
55862
55863 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55864 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55865 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55866 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55867 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55868 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55869 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55870 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55871 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55872 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55873 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55874 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55875 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55876 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55877 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55878 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55879 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55880 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55881 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55882 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55883 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55884 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55885 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55886 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55887 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55888 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55889 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55890 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55891 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55892 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55893 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55894 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55895 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55896 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55897 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55898 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55899 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55900 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55901 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55902 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55903 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55904 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55905 SWIG_Python_SetConstant(d, "CB_FILENAME",SWIG_From_int(static_cast< int >(wxCB_FILENAME)));
55906 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55907 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55908 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55909 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55910 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55911 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55912 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55913 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55914 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55915 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55916 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55917 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55918 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55919 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55920 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55921 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55922 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55923 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55924 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55925 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55926 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55927 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55928 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55929 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55930 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55931 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55932 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55933 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55934 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55935 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55936 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55937 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55938 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55939 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55940 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55941 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55942 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55943 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55944 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55945 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55946 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55947 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55948 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55949 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55950 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55951 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55952 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55953 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55954 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55955 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55956 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55957 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55958 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55959 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55960 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55961 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55962 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55963 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55964 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55965 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55966 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55967 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55968 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55969 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55970 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55971 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55972 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55973 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55974 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55975 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55976 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55977 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55978 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55979 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55980 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55981 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55982 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55983 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55984 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55985 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55986 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55987 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55988 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55989 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55990 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55991 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55992 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55993 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55994 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55995 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55996 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55997 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55998 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55999 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56000 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56001 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56002 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56003 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56004 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56005 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56006 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56007 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56008 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56009 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56010 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56011 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56012 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56013 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56014 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56015 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56016 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56017 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56018 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56019 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56020 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56021 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56022 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56023 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56024 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56025 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56026 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56027 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56028 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56029 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56030 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56031 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56032 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56033 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56034 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56035 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56036 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56037 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56038 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56039 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56040 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56041 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56042 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56043 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56044 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56045 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56046 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56047 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56048 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56049 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56050 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56051 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56052 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56053 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56054 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56055 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56056 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56057 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56058 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56059 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56060 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56061 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56062 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56063 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56064 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56065 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56066 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56067 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56068 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56069 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56070 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56071 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56072 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56073 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56074 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56075 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56076 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56077 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56078 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56079 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56080 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56081 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56082 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56083 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56084 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56085 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56086 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56087 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56088 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56089 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56090 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56091 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56092 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56093 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56094 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56095 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56096 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56097 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56098 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56099 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56100 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56101 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56102 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56103 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56104 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56105 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56106 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56107 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56108 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56109 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56110 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56111 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56112 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56113 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56114 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56115 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56116 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56117 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56118 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56119 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56120 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56121 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56122 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56123 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56124 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56125 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56126 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56127 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56128 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56129 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56130 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56131 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56132 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56133 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56134 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56135 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56136 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56137 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56138 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56139 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56140 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56141 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56142 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56143 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56144 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56145 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56146 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56147 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56148 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56149 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56150 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56151 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56152 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56153 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56154 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56155 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56156 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56157 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56158 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56159 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56160 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56161 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56162 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56163 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56164 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56165 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56166 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56167 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56168 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56169 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56170 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56171 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56172 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56173 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56174 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56175 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56176 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56177 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56178 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56179 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56180 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56181 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56182 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56183 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56184 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56185 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56186 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56187 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56188 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56189 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56190 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56191 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56192 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56193 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56194 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56195 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56196 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56197 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56198 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56199 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56200 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56201 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56202 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56203 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56204 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56205 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56206 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56207 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56208 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56209 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56210 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56211 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56212 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56213 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56214 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56215 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56216 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56217 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56218 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56219 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56220 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56221 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56222 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56223 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56224 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56225 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56226 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56227 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56228 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56229 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56230 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56231 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56232 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56233 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56234 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56235 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56236 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56237 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56238 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56239 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56240 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56241 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56242 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56243 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56244 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56245 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56246 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56247 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56248 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56249 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56250 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56251 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56252 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56253 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56254 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56255 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56256 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56257 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56258 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56259 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56260 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56261 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56262 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56263 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56264 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56265 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56266 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56267 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56268 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56269 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56270 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56271 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56272 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56273 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56274 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56275 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56276 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56277 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56278 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56279 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56280 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56281 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56282 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56283 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56284 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56285 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56286 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56287 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56288 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56289 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56290 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56291 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56292 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56293 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56294 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56295 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56296 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56297 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56298 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56299 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56300 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56301 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56302 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56303 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56304 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56305 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56306 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56307 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56308 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56309 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56310 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56311 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56312 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56313 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56314 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56315 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56316 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56317 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56318 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56319 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56320 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56321 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56322 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56323 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56324 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56325 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56326 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56327 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56328 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56329 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56330 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56331 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56332 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56333 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56334 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56335 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56336 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56337 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56338 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56339 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56340 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56341 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56342 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56343 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56344 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56345 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56346 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56347 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56348 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56349 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56350 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56351 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56352 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56353 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56354 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56355 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56356 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56357 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56358 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56359 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56360 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56361 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56362 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56363 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56364 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56365 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56366 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56367 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56368 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56369 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56370 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56371 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56372 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56373 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56374 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56375 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56376 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56377 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56378 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56379 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56380 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56381 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56382 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56383 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56384 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56385 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56386 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56387 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56388 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56389 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56390 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56391 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56392 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56393 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56394 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56395 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56396 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56397 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56398 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56399 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56400 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56401 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56402 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56403 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56405 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56406 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56407 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56408 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56409 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56410 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56411 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56412 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56413 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56414 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56415 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56416 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56417 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56418 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56419 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56420 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56421 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56422 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56423 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56424 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56425 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56426 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56427 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56428 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56429 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56430 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56431 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56432 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56433 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56434 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56435 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56436 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56437 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56438 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56439 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56440 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56441 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56442 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56443 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56444 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56445 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56446 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56447 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56448 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56449 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56450 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56451 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56452 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56453 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56454 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56455 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56456 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56457 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56458 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56459 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56460 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56461 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56462 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56463 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56464 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56465 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56466 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56467 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56468 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56469 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56470 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56471 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56472 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56473 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56474 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56475 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56476 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56477 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56478 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56479 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56480 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56481 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56482 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56483 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56484 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56485 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56486 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56487 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56488 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56489 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56490 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56491 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56492 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56493 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56494 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56495 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56496 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56497 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56498 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56499 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56500 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56501 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56502 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56503 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56504 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56505 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56506 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56507 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56508 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56509 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56510 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56511 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56512 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56513 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56514 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56515 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56516 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56517 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56518 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56519 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56520 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56521 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56522 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56523 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56524 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56525 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56526 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56527 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56528 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56529
56530 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56531
56532
56533 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56534
56535 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56536 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56537 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56538 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56539 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56540 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56541 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56542 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56543 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56544 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56545 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56546 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56547 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56548 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56549 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56550 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56551 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56552 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56553 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56554 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56555 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56556 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56557 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56558 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56559 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56560 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56561 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56562 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56563 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56564 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56565 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56566 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56567 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56568 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56569 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56570 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56571 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56572 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56573 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56574 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56575 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56576 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56577 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56578 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56579 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56580 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56581 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56582 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56583 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56584 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56585 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56586 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56587 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56588 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56589 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56590 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56591 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56592 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56593 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56594 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56595 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56596 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56597 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56598 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56599 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56600 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56601 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56602 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56603 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56604 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56605 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56606 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56607 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56608 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56609 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56610 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56611 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56612 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56613 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56614 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56615 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56616 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56617 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56618 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56619 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56620 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56621 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56622 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56623 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56624 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56625 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56626 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56627 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56628 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56629 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56630 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56631 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56632 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56633 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56634 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56635 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56636 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56637 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56638 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56639 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56640 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56641 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56642 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56643 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56644 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56645 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56646 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56647 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56648 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56649 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56650 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56651 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56652 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56653 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56654 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56655 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56656 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56657 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56658 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56659 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56660 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56661 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56662 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56663 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56664 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56665 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56666 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56667 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56668 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56669 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56670 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56671 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56672 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56673 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56674 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56675 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56676 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56677 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56678 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56679 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56680 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56681 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56682 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56683 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56684 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56685 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56686 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56687 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56688 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56689 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56690 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56691 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56692 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56693 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56694 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56695 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56696 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56697 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56698 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56699 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56700 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56701 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56702 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56703 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56704 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56705 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56706 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56707 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56708 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56709 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56710 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56711 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56712 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56713 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56714 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56715 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56716 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56717 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56718 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56719 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56720 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56721 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56722 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56723 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56724 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56725 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56726 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56727 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56728 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56729 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56730 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56731 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56732 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56733 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56734 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56735 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56736 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56737 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56738 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56739 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56740 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56741 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56742
56743 // Initialize threading, some globals and such
56744 __wxPyPreStart(d);
56745
56746
56747 // Although these are defined in __version__ they need to be here too so
56748 // that an assert can be done to ensure that the wxPython and the wxWindows
56749 // versions match.
56750 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56751 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56752 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56753
56754 }
56755
wxWidgets (Impactor)