]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added Bryan's new icons
[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_wxLayoutDirection swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRegion swig_types[110]
2577 #define SWIGTYPE_p_wxScrollEvent swig_types[111]
2578 #define SWIGTYPE_p_wxScrollWinEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSetCursorEvent swig_types[113]
2580 #define SWIGTYPE_p_wxShowEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSize swig_types[115]
2582 #define SWIGTYPE_p_wxSizeEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSizer swig_types[117]
2584 #define SWIGTYPE_p_wxSizerItem swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBox swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[121]
2588 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[122]
2589 #define SWIGTYPE_p_wxTIFFHandler swig_types[123]
2590 #define SWIGTYPE_p_wxToolTip swig_types[124]
2591 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[125]
2592 #define SWIGTYPE_p_wxValidator swig_types[126]
2593 #define SWIGTYPE_p_wxVisualAttributes swig_types[127]
2594 #define SWIGTYPE_p_wxWindow swig_types[128]
2595 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[129]
2596 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[130]
2597 #define SWIGTYPE_p_wxXPMHandler swig_types[131]
2598 #define SWIGTYPE_p_wxZipFSHandler swig_types[132]
2599 static swig_type_info *swig_types[134];
2600 static swig_module_info swig_module = {swig_types, 133, 0, 0, 0, 0};
2601 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2602 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2603
2604 /* -------- TYPES TABLE (END) -------- */
2605
2606 #if (PY_VERSION_HEX <= 0x02000000)
2607 # if !defined(SWIG_PYTHON_CLASSIC)
2608 # error "This python version requires to use swig with the '-classic' option"
2609 # endif
2610 #endif
2611 #if (PY_VERSION_HEX <= 0x02020000)
2612 # error "This python version requires to use swig with the '-nomodern' option"
2613 #endif
2614 #if (PY_VERSION_HEX <= 0x02020000)
2615 # error "This python version requires to use swig with the '-nomodernargs' option"
2616 #endif
2617 #ifndef METH_O
2618 # error "This python version requires to use swig with the '-nofastunpack' option"
2619 #endif
2620
2621 /*-----------------------------------------------
2622 @(target):= _core_.so
2623 ------------------------------------------------*/
2624 #define SWIG_init init_core_
2625
2626 #define SWIG_name "_core_"
2627
2628 #define SWIGVERSION 0x010329
2629
2630
2631 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2632 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2633
2634
2635 #include <stdexcept>
2636
2637
2638 namespace swig {
2639 class PyObject_ptr {
2640 protected:
2641 PyObject *_obj;
2642
2643 public:
2644 PyObject_ptr() :_obj(0)
2645 {
2646 }
2647
2648 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2649 {
2650 Py_XINCREF(_obj);
2651 }
2652
2653 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2654 {
2655 if (initial_ref) Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr & operator=(const PyObject_ptr& item)
2659 {
2660 Py_XINCREF(item._obj);
2661 Py_XDECREF(_obj);
2662 _obj = item._obj;
2663 return *this;
2664 }
2665
2666 ~PyObject_ptr()
2667 {
2668 Py_XDECREF(_obj);
2669 }
2670
2671 operator PyObject *() const
2672 {
2673 return _obj;
2674 }
2675
2676 PyObject *operator->() const
2677 {
2678 return _obj;
2679 }
2680 };
2681 }
2682
2683
2684 namespace swig {
2685 struct PyObject_var : PyObject_ptr {
2686 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2687
2688 PyObject_var & operator = (PyObject* obj)
2689 {
2690 Py_XDECREF(_obj);
2691 _obj = obj;
2692 return *this;
2693 }
2694 };
2695 }
2696
2697
2698 #include "wx/wxPython/wxPython_int.h"
2699 #include "wx/wxPython/pyclasses.h"
2700 #include "wx/wxPython/twoitem.h"
2701
2702
2703 #ifndef wxPyUSE_EXPORT
2704 // Helper functions for dealing with SWIG objects and such. These are
2705 // located here so they know about the SWIG types and functions declared
2706 // in the wrapper code.
2707
2708 #include <wx/hashmap.h>
2709 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2710
2711
2712 // Maintains a hashmap of className to swig_type_info pointers. Given the
2713 // name of a class either looks up the type info in the cache, or scans the
2714 // SWIG tables for it.
2715 extern PyObject* wxPyPtrTypeMap;
2716 static
2717 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2718
2719 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2720
2721 if (typeInfoCache == NULL)
2722 typeInfoCache = new wxPyTypeInfoHashMap;
2723
2724 wxString name(className);
2725 swig_type_info* swigType = (*typeInfoCache)[name];
2726
2727 if (! swigType) {
2728 // it wasn't in the cache, so look it up from SWIG
2729 name.Append(wxT(" *"));
2730 swigType = SWIG_TypeQuery(name.mb_str());
2731
2732 // if it still wasn't found, try looking for a mapped name
2733 if (!swigType) {
2734 PyObject* item;
2735 name = className;
2736
2737 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2738 (char*)(const char*)name.mbc_str())) != NULL) {
2739 name = wxString(PyString_AsString(item), *wxConvCurrent);
2740 name.Append(wxT(" *"));
2741 swigType = SWIG_TypeQuery(name.mb_str());
2742 }
2743 }
2744 if (swigType) {
2745 // and add it to the map if found
2746 (*typeInfoCache)[className] = swigType;
2747 }
2748 }
2749 return swigType;
2750 }
2751
2752
2753 // Check if a class name is a type known to SWIG
2754 bool wxPyCheckSwigType(const wxChar* className) {
2755
2756 swig_type_info* swigType = wxPyFindSwigType(className);
2757 return swigType != NULL;
2758 }
2759
2760
2761 // Given a pointer to a C++ object and a class name, construct a Python proxy
2762 // object for it.
2763 PyObject* wxPyConstructObject(void* ptr,
2764 const wxChar* className,
2765 int setThisOwn) {
2766
2767 swig_type_info* swigType = wxPyFindSwigType(className);
2768 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2769
2770 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2771 }
2772
2773
2774 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2775 // Ensures that the proxy object is of the specified (or derived) type. If
2776 // not able to perform the conversion then a Python exception is set and the
2777 // error should be handled properly in the caller. Returns True on success.
2778 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2779 const wxChar* className) {
2780
2781 swig_type_info* swigType = wxPyFindSwigType(className);
2782 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2783
2784 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2785 }
2786
2787
2788
2789 // Make a SWIGified pointer object suitable for a .this attribute
2790 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2791
2792 PyObject* robj = NULL;
2793
2794 swig_type_info* swigType = wxPyFindSwigType(className);
2795 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2796
2797 robj = PySwigObject_New(ptr, swigType, 0);
2798 return robj;
2799 }
2800
2801
2802 // Python's PyInstance_Check does not return True for instances of new-style
2803 // classes. This should get close enough for both new and old classes but I
2804 // should re-evaluate the need for doing instance checks...
2805 bool wxPyInstance_Check(PyObject* obj) {
2806 return PyObject_HasAttrString(obj, "__class__") != 0;
2807 }
2808
2809
2810 // This one checks if the object is an instance of a SWIG proxy class (it has
2811 // a .this attribute, and the .this attribute is a PySwigObject.)
2812 bool wxPySwigInstance_Check(PyObject* obj) {
2813 static PyObject* this_str = NULL;
2814 if (this_str == NULL)
2815 this_str = PyString_FromString("this");
2816
2817 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2818 if (this_attr) {
2819 bool retval = (PySwigObject_Check(this_attr) != 0);
2820 Py_DECREF(this_attr);
2821 return retval;
2822 }
2823
2824 PyErr_Clear();
2825 return false;
2826 }
2827
2828
2829 // Export a C API in a struct. Other modules will be able to load this from
2830 // the wx._core_ module and will then have safe access to these functions,
2831 // even if they are located in another shared library.
2832 static wxPyCoreAPI API = {
2833
2834 wxPyCheckSwigType,
2835 wxPyConstructObject,
2836 wxPyConvertSwigPtr,
2837 wxPyMakeSwigPtr,
2838
2839 wxPyBeginAllowThreads,
2840 wxPyEndAllowThreads,
2841 wxPyBeginBlockThreads,
2842 wxPyEndBlockThreads,
2843
2844 wxPy_ConvertList,
2845
2846 wxString_in_helper,
2847 Py2wxString,
2848 wx2PyString,
2849
2850 byte_LIST_helper,
2851 int_LIST_helper,
2852 long_LIST_helper,
2853 string_LIST_helper,
2854 wxPoint_LIST_helper,
2855 wxBitmap_LIST_helper,
2856 wxString_LIST_helper,
2857 wxAcceleratorEntry_LIST_helper,
2858
2859 wxSize_helper,
2860 wxPoint_helper,
2861 wxRealPoint_helper,
2862 wxRect_helper,
2863 wxColour_helper,
2864 wxPoint2D_helper,
2865
2866 wxPySimple_typecheck,
2867 wxColour_typecheck,
2868
2869 wxPyCBH_setCallbackInfo,
2870 wxPyCBH_findCallback,
2871 wxPyCBH_callCallback,
2872 wxPyCBH_callCallbackObj,
2873 wxPyCBH_delete,
2874
2875 wxPyMake_wxObject,
2876 wxPyMake_wxSizer,
2877 wxPyPtrTypeMap_Add,
2878 wxPy2int_seq_helper,
2879 wxPy4int_seq_helper,
2880 wxArrayString2PyList_helper,
2881 wxArrayInt2PyList_helper,
2882
2883 wxPyClientData_dtor,
2884 wxPyUserData_dtor,
2885 wxPyOORClientData_dtor,
2886
2887 wxPyCBInputStream_create,
2888 wxPyCBInputStream_copy,
2889
2890 wxPyInstance_Check,
2891 wxPySwigInstance_Check,
2892
2893 wxPyCheckForApp
2894
2895 };
2896
2897 #endif
2898
2899
2900 #if !WXWIN_COMPATIBILITY_2_4
2901 #define wxHIDE_READONLY 0
2902 #endif
2903
2904
2905 #define SWIG_From_long PyInt_FromLong
2906
2907
2908 SWIGINTERNINLINE PyObject *
2909 SWIG_From_int (int value)
2910 {
2911 return SWIG_From_long (value);
2912 }
2913
2914 static const wxString wxPyEmptyString(wxEmptyString);
2915 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2916 return self->GetClassInfo()->GetClassName();
2917 }
2918 SWIGINTERN void wxObject_Destroy(wxObject *self){
2919 delete self;
2920 }
2921
2922 #ifndef __WXMAC__
2923 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2924 #endif
2925
2926
2927 #include <limits.h>
2928 #ifndef LLONG_MIN
2929 # define LLONG_MIN LONG_LONG_MIN
2930 #endif
2931 #ifndef LLONG_MAX
2932 # define LLONG_MAX LONG_LONG_MAX
2933 #endif
2934 #ifndef ULLONG_MAX
2935 # define ULLONG_MAX ULONG_LONG_MAX
2936 #endif
2937
2938
2939 SWIGINTERN int
2940 SWIG_AsVal_long (PyObject* obj, long* val)
2941 {
2942 if (PyNumber_Check(obj)) {
2943 if (val) *val = PyInt_AsLong(obj);
2944 return SWIG_OK;
2945 }
2946 return SWIG_TypeError;
2947 }
2948
2949
2950 SWIGINTERN int
2951 SWIG_AsVal_int (PyObject * obj, int *val)
2952 {
2953 long v;
2954 int res = SWIG_AsVal_long (obj, &v);
2955 if (SWIG_IsOK(res)) {
2956 if ((v < INT_MIN || v > INT_MAX)) {
2957 return SWIG_OverflowError;
2958 } else {
2959 if (val) *val = static_cast< int >(v);
2960 }
2961 }
2962 return res;
2963 }
2964
2965 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return false;
2968 if ( ! wxSize_helper(other, &obj) ) {
2969 PyErr_Clear();
2970 return false;
2971 }
2972 return self->operator==(*obj);
2973 }
2974 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2975 wxSize temp, *obj = &temp;
2976 if ( other == Py_None ) return true;
2977 if ( ! wxSize_helper(other, &obj)) {
2978 PyErr_Clear();
2979 return true;
2980 }
2981 return self->operator!=(*obj);
2982 }
2983
2984 #include <float.h>
2985
2986
2987 SWIGINTERN int
2988 SWIG_AsVal_double (PyObject *obj, double* val)
2989 {
2990 if (PyNumber_Check(obj)) {
2991 if (val) *val = PyFloat_AsDouble(obj);
2992 return SWIG_OK;
2993 }
2994 return SWIG_TypeError;
2995 }
2996
2997
2998 SWIGINTERN int
2999 SWIG_AsVal_float (PyObject * obj, float *val)
3000 {
3001 double v;
3002 int res = SWIG_AsVal_double (obj, &v);
3003 if (SWIG_IsOK(res)) {
3004 if ((v < -FLT_MAX || v > FLT_MAX)) {
3005 return SWIG_OverflowError;
3006 } else {
3007 if (val) *val = static_cast< float >(v);
3008 }
3009 }
3010 return res;
3011 }
3012
3013 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 PyObject* tup = PyTuple_New(2);
3016 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3017 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3018 wxPyEndBlockThreads(blocked);
3019 return tup;
3020 }
3021
3022 #define SWIG_From_double PyFloat_FromDouble
3023
3024 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3025 wxRealPoint temp, *obj = &temp;
3026 if ( other == Py_None ) return false;
3027 if ( ! wxRealPoint_helper(other, &obj) ) {
3028 PyErr_Clear();
3029 return false;
3030 }
3031 return self->operator==(*obj);
3032 }
3033 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3034 wxRealPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return true;
3036 if ( ! wxRealPoint_helper(other, &obj)) {
3037 PyErr_Clear();
3038 return true;
3039 }
3040 return self->operator!=(*obj);
3041 }
3042 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3043 self->x = x;
3044 self->y = y;
3045 }
3046 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3048 PyObject* tup = PyTuple_New(2);
3049 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3050 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3051 wxPyEndBlockThreads(blocked);
3052 return tup;
3053 }
3054 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3055 wxPoint temp, *obj = &temp;
3056 if ( other == Py_None ) return false;
3057 if ( ! wxPoint_helper(other, &obj) ) {
3058 PyErr_Clear();
3059 return false;
3060 }
3061 return self->operator==(*obj);
3062 }
3063 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3064 wxPoint temp, *obj = &temp;
3065 if ( other == Py_None ) return true;
3066 if ( ! wxPoint_helper(other, &obj)) {
3067 PyErr_Clear();
3068 return true;
3069 }
3070 return self->operator!=(*obj);
3071 }
3072 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3073 self->x = x;
3074 self->y = y;
3075 }
3076 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 PyObject* tup = PyTuple_New(2);
3079 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3080 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3081 wxPyEndBlockThreads(blocked);
3082 return tup;
3083 }
3084 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3085 wxRect temp, *obj = &temp;
3086 if ( other == Py_None ) return false;
3087 if ( ! wxRect_helper(other, &obj) ) {
3088 PyErr_Clear();
3089 return false;
3090 }
3091 return self->operator==(*obj);
3092 }
3093 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3094 wxRect temp, *obj = &temp;
3095 if ( other == Py_None ) return true;
3096 if ( ! wxRect_helper(other, &obj)) {
3097 PyErr_Clear();
3098 return true;
3099 }
3100 return self->operator!=(*obj);
3101 }
3102 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3103 self->x = x;
3104 self->y = y;
3105 self->width = width;
3106 self->height = height;
3107 }
3108 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3110 PyObject* tup = PyTuple_New(4);
3111 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3112 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3113 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3114 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3115 wxPyEndBlockThreads(blocked);
3116 return tup;
3117 }
3118
3119 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3120 wxRegion reg1(*r1);
3121 wxRegion reg2(*r2);
3122 wxRect dest(0,0,0,0);
3123 PyObject* obj;
3124
3125 reg1.Intersect(reg2);
3126 dest = reg1.GetBox();
3127
3128 if (dest != wxRect(0,0,0,0)) {
3129 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3130 wxRect* newRect = new wxRect(dest);
3131 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3132 wxPyEndBlockThreads(blocked);
3133 return obj;
3134 }
3135 Py_INCREF(Py_None);
3136 return Py_None;
3137 }
3138
3139 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3140 wxPoint2D temp, *obj = &temp;
3141 if ( other == Py_None ) return false;
3142 if ( ! wxPoint2D_helper(other, &obj) ) {
3143 PyErr_Clear();
3144 return false;
3145 }
3146 return self->operator==(*obj);
3147 }
3148 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3149 wxPoint2D temp, *obj = &temp;
3150 if ( other == Py_None ) return true;
3151 if ( ! wxPoint2D_helper(other, &obj)) {
3152 PyErr_Clear();
3153 return true;
3154 }
3155 return self->operator!=(*obj);
3156 }
3157 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3158 self->m_x = x;
3159 self->m_y = y;
3160 }
3161 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3163 PyObject* tup = PyTuple_New(2);
3164 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3165 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3166 wxPyEndBlockThreads(blocked);
3167 return tup;
3168 }
3169
3170 #include "wx/wxPython/pyistream.h"
3171
3172 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3173 wxInputStream* wxis = wxPyCBInputStream::create(p);
3174 if (wxis)
3175 return new wxPyInputStream(wxis);
3176 else
3177 return NULL;
3178 }
3179
3180 SWIGINTERN swig_type_info*
3181 SWIG_pchar_descriptor()
3182 {
3183 static int init = 0;
3184 static swig_type_info* info = 0;
3185 if (!init) {
3186 info = SWIG_TypeQuery("_p_char");
3187 init = 1;
3188 }
3189 return info;
3190 }
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3195 {
3196 if (carray) {
3197 if (size > INT_MAX) {
3198 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3199 return pchar_descriptor ?
3200 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3201 } else {
3202 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3203 }
3204 } else {
3205 return SWIG_Py_Void();
3206 }
3207 }
3208
3209
3210 SWIGINTERNINLINE PyObject *
3211 SWIG_From_char (char c)
3212 {
3213 return SWIG_FromCharPtrAndSize(&c,1);
3214 }
3215
3216
3217 SWIGINTERNINLINE PyObject*
3218 SWIG_From_unsigned_SS_long (unsigned long value)
3219 {
3220 return (value > LONG_MAX) ?
3221 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3222 }
3223
3224
3225 SWIGINTERNINLINE PyObject *
3226 SWIG_From_size_t (size_t value)
3227 {
3228 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3229 }
3230
3231
3232 SWIGINTERN int
3233 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3234 {
3235 if (PyString_Check(obj)) {
3236 char *cstr; Py_ssize_t len;
3237 PyString_AsStringAndSize(obj, &cstr, &len);
3238 if (cptr) {
3239 if (alloc) {
3240 /*
3241 In python the user should not be able to modify the inner
3242 string representation. To warranty that, if you define
3243 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3244 buffer is always returned.
3245
3246 The default behavior is just to return the pointer value,
3247 so, be careful.
3248 */
3249 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3250 if (*alloc != SWIG_OLDOBJ)
3251 #else
3252 if (*alloc == SWIG_NEWOBJ)
3253 #endif
3254 {
3255 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3256 *alloc = SWIG_NEWOBJ;
3257 }
3258 else {
3259 *cptr = cstr;
3260 *alloc = SWIG_OLDOBJ;
3261 }
3262 } else {
3263 *cptr = PyString_AsString(obj);
3264 }
3265 }
3266 if (psize) *psize = len + 1;
3267 return SWIG_OK;
3268 } else {
3269 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3270 if (pchar_descriptor) {
3271 void* vptr = 0;
3272 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3273 if (cptr) *cptr = (char *) vptr;
3274 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3275 if (alloc) *alloc = SWIG_OLDOBJ;
3276 return SWIG_OK;
3277 }
3278 }
3279 }
3280 return SWIG_TypeError;
3281 }
3282
3283
3284 SWIGINTERN int
3285 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3286 {
3287 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3288 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3289 if (SWIG_IsOK(res)) {
3290 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3291 if (csize <= size) {
3292 if (val) {
3293 if (csize) memcpy(val, cptr, csize*sizeof(char));
3294 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3295 }
3296 if (alloc == SWIG_NEWOBJ) {
3297 delete[] cptr;
3298 res = SWIG_DelNewMask(res);
3299 }
3300 return res;
3301 }
3302 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3303 }
3304 return SWIG_TypeError;
3305 }
3306
3307
3308 SWIGINTERN int
3309 SWIG_AsVal_char (PyObject * obj, char *val)
3310 {
3311 int res = SWIG_AsCharArray(obj, val, 1);
3312 if (!SWIG_IsOK(res)) {
3313 long v;
3314 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3315 if (SWIG_IsOK(res)) {
3316 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3317 if (val) *val = static_cast< char >(v);
3318 } else {
3319 res = SWIG_OverflowError;
3320 }
3321 }
3322 }
3323 return res;
3324 }
3325
3326 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3327 // We use only strings for the streams, not unicode
3328 PyObject* str = PyObject_Str(obj);
3329 if (! str) {
3330 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3331 return;
3332 }
3333 self->Write(PyString_AS_STRING(str),
3334 PyString_GET_SIZE(str));
3335 Py_DECREF(str);
3336 }
3337
3338 #include "wx/wxPython/pyistream.h"
3339
3340
3341 class wxPyFileSystemHandler : public wxFileSystemHandler
3342 {
3343 public:
3344 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3345
3346 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3347 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3348 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3349 DEC_PYCALLBACK_STRING__pure(FindNext);
3350
3351 wxString GetProtocol(const wxString& location) {
3352 return wxFileSystemHandler::GetProtocol(location);
3353 }
3354
3355 wxString GetLeftLocation(const wxString& location) {
3356 return wxFileSystemHandler::GetLeftLocation(location);
3357 }
3358
3359 wxString GetAnchor(const wxString& location) {
3360 return wxFileSystemHandler::GetAnchor(location);
3361 }
3362
3363 wxString GetRightLocation(const wxString& location) {
3364 return wxFileSystemHandler::GetRightLocation(location);
3365 }
3366
3367 wxString GetMimeTypeFromExt(const wxString& location) {
3368 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3369 }
3370
3371 PYPRIVATE;
3372 };
3373
3374
3375 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3376 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3377 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3378 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3379
3380
3381 SWIGINTERN int
3382 SWIG_AsVal_bool (PyObject *obj, bool *val)
3383 {
3384 if (obj == Py_True) {
3385 if (val) *val = true;
3386 return SWIG_OK;
3387 } else if (obj == Py_False) {
3388 if (val) *val = false;
3389 return SWIG_OK;
3390 } else {
3391 long v = 0;
3392 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3393 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3394 return res;
3395 }
3396 }
3397
3398 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3399 wxFileName fname = wxFileSystem::URLToFileName(url);
3400 return fname.GetFullPath();
3401 }
3402
3403 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3404 wxImage& image,
3405 long type) {
3406 wxMemoryFSHandler::AddFile(filename, image, type);
3407 }
3408
3409 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3410 const wxBitmap& bitmap,
3411 long type) {
3412 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3413 }
3414
3415 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3416 PyObject* data) {
3417 if (! PyString_Check(data)) {
3418 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3419 "Expected string object"));
3420 return;
3421 }
3422
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 void* ptr = (void*)PyString_AsString(data);
3425 size_t size = PyString_Size(data);
3426 wxPyEndBlockThreads(blocked);
3427
3428 wxMemoryFSHandler::AddFile(filename, ptr, size);
3429 }
3430
3431
3432 #include "wx/wxPython/pyistream.h"
3433
3434
3435 SWIGINTERN int
3436 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3437 {
3438 long v = 0;
3439 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3440 return SWIG_TypeError;
3441 }
3442 else if (val)
3443 *val = (unsigned long)v;
3444 return SWIG_OK;
3445 }
3446
3447
3448 SWIGINTERN int
3449 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3450 {
3451 unsigned long v;
3452 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3453 if (SWIG_IsOK(res)) {
3454 if ((v > UCHAR_MAX)) {
3455 return SWIG_OverflowError;
3456 } else {
3457 if (val) *val = static_cast< unsigned char >(v);
3458 }
3459 }
3460 return res;
3461 }
3462
3463
3464 SWIGINTERNINLINE PyObject *
3465 SWIG_From_unsigned_SS_char (unsigned char value)
3466 {
3467 return SWIG_From_unsigned_SS_long (value);
3468 }
3469
3470 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3471 wxImageHistogramEntry e = (*self)[key];
3472 return e.value;
3473 }
3474 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3475 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3476 wxImageHistogramEntry e = (*self)[key];
3477 return e.value;
3478 }
3479 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3480 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3481 colour.Green(),
3482 colour.Blue());
3483 wxImageHistogramEntry e = (*self)[key];
3484 return e.value;
3485 }
3486
3487 // Pull the nested class out to the top level for SWIG's sake
3488 #define wxImage_RGBValue wxImage::RGBValue
3489 #define wxImage_HSVValue wxImage::HSVValue
3490
3491 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3492 if (width > 0 && height > 0)
3493 return new wxImage(width, height, clear);
3494 else
3495 return new wxImage;
3496 }
3497 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3498 return new wxImage(bitmap.ConvertToImage());
3499 }
3500 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3501 if (DATASIZE != width*height*3) {
3502 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3503 return NULL;
3504 }
3505
3506 // Copy the source data so the wxImage can clean it up later
3507 buffer copy = (buffer)malloc(DATASIZE);
3508 if (copy == NULL) {
3509 wxPyBLOCK_THREADS(PyErr_NoMemory());
3510 return NULL;
3511 }
3512 memcpy(copy, data, DATASIZE);
3513 return new wxImage(width, height, copy, false);
3514 }
3515 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3516 if (DATASIZE != width*height*3) {
3517 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3518 return NULL;
3519 }
3520 if (ALPHASIZE != width*height) {
3521 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3522 return NULL;
3523 }
3524
3525 // Copy the source data so the wxImage can clean it up later
3526 buffer dcopy = (buffer)malloc(DATASIZE);
3527 if (dcopy == NULL) {
3528 wxPyBLOCK_THREADS(PyErr_NoMemory());
3529 return NULL;
3530 }
3531 memcpy(dcopy, data, DATASIZE);
3532
3533 buffer acopy = (buffer)malloc(ALPHASIZE);
3534 if (acopy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return NULL;
3537 }
3538 memcpy(acopy, alpha, ALPHASIZE);
3539
3540 return new wxImage(width, height, dcopy, acopy, false);
3541 }
3542 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3543 wxSize size(self->GetWidth(), self->GetHeight());
3544 return size;
3545 }
3546 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3547 buffer data = self->GetData();
3548 int len = self->GetWidth() * self->GetHeight() * 3;
3549 PyObject* rv;
3550 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3551 return rv;
3552 }
3553 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3554 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3555 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3556 return;
3557 }
3558 buffer copy = (buffer)malloc(DATASIZE);
3559 if (copy == NULL) {
3560 wxPyBLOCK_THREADS(PyErr_NoMemory());
3561 return;
3562 }
3563 memcpy(copy, data, DATASIZE);
3564 self->SetData(copy, false);
3565 // wxImage takes ownership of copy...
3566 }
3567 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3568 buffer data = self->GetData();
3569 int len = self->GetWidth() * self->GetHeight() * 3;
3570 PyObject* rv;
3571 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3572 return rv;
3573 }
3574 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3575 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3577 return;
3578 }
3579 self->SetData(data, true);
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 if (! data) {
3584 RETURN_NONE();
3585 } else {
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3589 return rv;
3590 }
3591 }
3592 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3593 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3595 return;
3596 }
3597 buffer acopy = (buffer)malloc(ALPHASIZE);
3598 if (acopy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(acopy, alpha, ALPHASIZE);
3603 self->SetAlpha(acopy, false);
3604 // wxImage takes ownership of acopy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3607 buffer data = self->GetAlpha();
3608 int len = self->GetWidth() * self->GetHeight();
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3614 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3616 return;
3617 }
3618 self->SetAlpha(alpha, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetHandlers(){
3621 wxList& list = wxImage::GetHandlers();
3622 return wxPy_ConvertList(&list);
3623 }
3624 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3625 wxBitmap bitmap(*self, depth);
3626 return bitmap;
3627 }
3628 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3629 wxImage mono = self->ConvertToMono( red, green, blue );
3630 wxBitmap bitmap( mono, 1 );
3631 return bitmap;
3632 }
3633
3634 wxImage* _ImageFromBuffer(int width, int height,
3635 buffer data, int DATASIZE,
3636 buffer alpha=NULL, int ALPHASIZE=0)
3637 {
3638 if (DATASIZE != width*height*3) {
3639 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3640 return NULL;
3641 }
3642 if (alpha != NULL) {
3643 if (ALPHASIZE != width*height) {
3644 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3645 return NULL;
3646 }
3647 return new wxImage(width, height, data, alpha, true);
3648 }
3649 return new wxImage(width, height, data, true);
3650 }
3651
3652 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3653 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3660 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3661 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3662 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3663 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3664 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3665 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3666 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3667
3668 #include <wx/quantize.h>
3669
3670 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3671 return wxQuantize::Quantize(src, dest,
3672 //NULL, // palette
3673 desiredNoColours,
3674 NULL, // eightBitData
3675 flags);
3676 }
3677 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3678 if (PyCallable_Check(func)) {
3679 self->Connect(id, lastId, eventType,
3680 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3681 new wxPyCallback(func));
3682 }
3683 else if (func == Py_None) {
3684 self->Disconnect(id, lastId, eventType,
3685 (wxObjectEventFunction)
3686 &wxPyCallback::EventThunker);
3687 }
3688 else {
3689 wxPyBLOCK_THREADS(
3690 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3691 }
3692 }
3693 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3694 return self->Disconnect(id, lastId, eventType,
3695 (wxObjectEventFunction)
3696 &wxPyCallback::EventThunker);
3697 }
3698 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3699 if (_self && _self != Py_None) {
3700 self->SetClientObject(new wxPyOORClientData(_self, incref));
3701 }
3702 else {
3703 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3704 if (data) {
3705 self->SetClientObject(NULL); // This will delete it too
3706 }
3707 }
3708 }
3709
3710 #if ! wxUSE_HOTKEY
3711 #define wxEVT_HOTKEY -9999
3712 #endif
3713
3714 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3715 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3716 if (data) {
3717 Py_INCREF(data->m_obj);
3718 return data->m_obj;
3719 } else {
3720 Py_INCREF(Py_None);
3721 return Py_None;
3722 }
3723 }
3724 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3725 wxPyClientData* data = new wxPyClientData(clientData);
3726 self->SetClientObject(data);
3727 }
3728 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3729 #if wxUSE_UNICODE
3730 return self->GetUnicodeKey();
3731 #else
3732 return 0;
3733 #endif
3734 }
3735 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3736 #if wxUSE_UNICODE
3737 self->m_uniChar = uniChar;
3738 #endif
3739 }
3740
3741 SWIGINTERNINLINE PyObject *
3742 SWIG_From_unsigned_SS_int (unsigned int value)
3743 {
3744 return SWIG_From_unsigned_SS_long (value);
3745 }
3746
3747
3748 SWIGINTERN int
3749 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3750 {
3751 unsigned long v;
3752 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3753 if (SWIG_IsOK(res)) {
3754 if ((v > UINT_MAX)) {
3755 return SWIG_OverflowError;
3756 } else {
3757 if (val) *val = static_cast< unsigned int >(v);
3758 }
3759 }
3760 return res;
3761 }
3762
3763 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3764 self->m_size = size;
3765 }
3766 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3767 int count = self->GetNumberOfFiles();
3768 wxString* files = self->GetFiles();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 PyObject* list = PyList_New(count);
3771
3772 if (!list) {
3773 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3774 wxPyEndBlockThreads(blocked);
3775 return NULL;
3776 }
3777
3778 for (int i=0; i<count; i++) {
3779 PyList_SetItem(list, i, wx2PyString(files[i]));
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return list;
3783 }
3784
3785
3786 SWIGINTERN wxPyApp *new_wxPyApp(){
3787 wxPythonApp = new wxPyApp();
3788 return wxPythonApp;
3789 }
3790 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 static const wxString wxPyControlNameStr(wxControlNameStr);
3935 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3936 if (clientData) {
3937 wxPyClientData* data = new wxPyClientData(clientData);
3938 return self->Append(item, data);
3939 } else
3940 return self->Append(item);
3941 }
3942 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3943 if (clientData) {
3944 wxPyClientData* data = new wxPyClientData(clientData);
3945 return self->Insert(item, pos, data);
3946 } else
3947 return self->Insert(item, pos);
3948 }
3949 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3950 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3951 if (data) {
3952 Py_INCREF(data->m_obj);
3953 return data->m_obj;
3954 } else {
3955 Py_INCREF(Py_None);
3956 return Py_None;
3957 }
3958 }
3959 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3960 wxPyClientData* data = new wxPyClientData(clientData);
3961 self->SetClientObject(n, data);
3962 }
3963
3964
3965 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3966 wxPyUserData* data = NULL;
3967 if ( userData ) {
3968 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3969 data = new wxPyUserData(userData);
3970 wxPyEndBlockThreads(blocked);
3971 }
3972 return new wxSizerItem(window, proportion, flag, border, data);
3973 }
3974 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3975 wxPyUserData* data = NULL;
3976 if ( userData ) {
3977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3978 data = new wxPyUserData(userData);
3979 wxPyEndBlockThreads(blocked);
3980 }
3981 return new wxSizerItem(width, height, proportion, flag, border, data);
3982 }
3983 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3984 wxPyUserData* data = NULL;
3985 if ( userData ) {
3986 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3987 data = new wxPyUserData(userData);
3988 wxPyEndBlockThreads(blocked);
3989 }
3990 return new wxSizerItem(sizer, proportion, flag, border, data);
3991 }
3992
3993 SWIGINTERNINLINE PyObject *
3994 SWIG_From_float (float value)
3995 {
3996 return SWIG_From_double (value);
3997 }
3998
3999 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4000 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4001 if (data) {
4002 Py_INCREF(data->m_obj);
4003 return data->m_obj;
4004 } else {
4005 Py_INCREF(Py_None);
4006 return Py_None;
4007 }
4008 }
4009 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4010 wxPyUserData* data = NULL;
4011 if ( userData ) {
4012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4013 data = new wxPyUserData(userData);
4014 wxPyEndBlockThreads(blocked);
4015 }
4016 self->SetUserData(data);
4017 }
4018
4019 // Figure out the type of the sizer item
4020
4021 struct wxPySizerItemInfo {
4022 wxPySizerItemInfo()
4023 : window(NULL), sizer(NULL), gotSize(false),
4024 size(wxDefaultSize), gotPos(false), pos(-1)
4025 {}
4026
4027 wxWindow* window;
4028 wxSizer* sizer;
4029 bool gotSize;
4030 wxSize size;
4031 bool gotPos;
4032 int pos;
4033 };
4034
4035 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4036
4037 wxPySizerItemInfo info;
4038 wxSize size;
4039 wxSize* sizePtr = &size;
4040
4041 // Find out what the type of the item is
4042 // try wxWindow
4043 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4044 PyErr_Clear();
4045 info.window = NULL;
4046
4047 // try wxSizer
4048 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4049 PyErr_Clear();
4050 info.sizer = NULL;
4051
4052 // try wxSize or (w,h)
4053 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4054 info.size = *sizePtr;
4055 info.gotSize = true;
4056 }
4057
4058 // or a single int
4059 if (checkIdx && PyInt_Check(item)) {
4060 info.pos = PyInt_AsLong(item);
4061 info.gotPos = true;
4062 }
4063 }
4064 }
4065
4066 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4067 // no expected type, figure out what kind of error message to generate
4068 if ( !checkSize && !checkIdx )
4069 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4070 else if ( checkSize && !checkIdx )
4071 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4072 else if ( !checkSize && checkIdx)
4073 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4074 else
4075 // can this one happen?
4076 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4077 }
4078
4079 return info;
4080 }
4081
4082 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4083 if (!self->GetClientObject())
4084 self->SetClientObject(new wxPyOORClientData(_self));
4085 }
4086 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4087
4088 wxPyUserData* data = NULL;
4089 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4090 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4091 if ( userData && (info.window || info.sizer || info.gotSize) )
4092 data = new wxPyUserData(userData);
4093 if ( info.sizer )
4094 PyObject_SetAttrString(item,"thisown",Py_False);
4095 wxPyEndBlockThreads(blocked);
4096
4097 // Now call the real Add method if a valid item type was found
4098 if ( info.window )
4099 return self->Add(info.window, proportion, flag, border, data);
4100 else if ( info.sizer )
4101 return self->Add(info.sizer, proportion, flag, border, data);
4102 else if (info.gotSize)
4103 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4104 proportion, flag, border, data);
4105 else
4106 return NULL;
4107 }
4108 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4109
4110 wxPyUserData* data = NULL;
4111 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4112 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4113 if ( userData && (info.window || info.sizer || info.gotSize) )
4114 data = new wxPyUserData(userData);
4115 if ( info.sizer )
4116 PyObject_SetAttrString(item,"thisown",Py_False);
4117 wxPyEndBlockThreads(blocked);
4118
4119 // Now call the real Insert method if a valid item type was found
4120 if ( info.window )
4121 return self->Insert(before, info.window, proportion, flag, border, data);
4122 else if ( info.sizer )
4123 return self->Insert(before, info.sizer, proportion, flag, border, data);
4124 else if (info.gotSize)
4125 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4126 proportion, flag, border, data);
4127 else
4128 return NULL;
4129 }
4130 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4131
4132 wxPyUserData* data = NULL;
4133 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4134 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4135 if ( userData && (info.window || info.sizer || info.gotSize) )
4136 data = new wxPyUserData(userData);
4137 if ( info.sizer )
4138 PyObject_SetAttrString(item,"thisown",Py_False);
4139 wxPyEndBlockThreads(blocked);
4140
4141 // Now call the real Prepend method if a valid item type was found
4142 if ( info.window )
4143 return self->Prepend(info.window, proportion, flag, border, data);
4144 else if ( info.sizer )
4145 return self->Prepend(info.sizer, proportion, flag, border, data);
4146 else if (info.gotSize)
4147 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4148 proportion, flag, border, data);
4149 else
4150 return NULL;
4151 }
4152 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4153 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4154 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4155 wxPyEndBlockThreads(blocked);
4156 if ( info.window )
4157 return self->Remove(info.window);
4158 else if ( info.sizer )
4159 return self->Remove(info.sizer);
4160 else if ( info.gotPos )
4161 return self->Remove(info.pos);
4162 else
4163 return false;
4164 }
4165 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4167 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4168 wxPyEndBlockThreads(blocked);
4169 if ( info.window )
4170 return self->Detach(info.window);
4171 else if ( info.sizer )
4172 return self->Detach(info.sizer);
4173 else if ( info.gotPos )
4174 return self->Detach(info.pos);
4175 else
4176 return false;
4177 }
4178 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4180 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4181 wxPyEndBlockThreads(blocked);
4182 if ( info.window )
4183 return self->GetItem(info.window);
4184 else if ( info.sizer )
4185 return self->GetItem(info.sizer);
4186 else if ( info.gotPos )
4187 return self->GetItem(info.pos);
4188 else
4189 return NULL;
4190 }
4191 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4194 wxPyEndBlockThreads(blocked);
4195 if ( info.window )
4196 self->SetItemMinSize(info.window, size);
4197 else if ( info.sizer )
4198 self->SetItemMinSize(info.sizer, size);
4199 else if ( info.gotPos )
4200 self->SetItemMinSize(info.pos, size);
4201 }
4202 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4203 wxSizerItemList& list = self->GetChildren();
4204 return wxPy_ConvertList(&list);
4205 }
4206 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 return self->Show(info.window, show, recursive);
4212 else if ( info.sizer )
4213 return self->Show(info.sizer, show, recursive);
4214 else if ( info.gotPos )
4215 return self->Show(info.pos, show);
4216 else
4217 return false;
4218 }
4219 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4221 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4222 wxPyEndBlockThreads(blocked);
4223 if ( info.window )
4224 return self->IsShown(info.window);
4225 else if ( info.sizer )
4226 return self->IsShown(info.sizer);
4227 else if ( info.gotPos )
4228 return self->IsShown(info.pos);
4229 else
4230 return false;
4231 }
4232
4233 // See pyclasses.h
4234 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4235 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4236 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4237
4238
4239
4240
4241 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4242 {
4243 if (source == Py_None) {
4244 **obj = wxGBPosition(-1,-1);
4245 return true;
4246 }
4247 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4248 }
4249
4250 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4251 {
4252 if (source == Py_None) {
4253 **obj = wxGBSpan(-1,-1);
4254 return true;
4255 }
4256 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4257 }
4258
4259
4260 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4261 wxGBPosition temp, *obj = &temp;
4262 if ( other == Py_None ) return false;
4263 if ( ! wxGBPosition_helper(other, &obj) ) {
4264 PyErr_Clear();
4265 return false;
4266 }
4267 return self->operator==(*obj);
4268 }
4269 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4270 wxGBPosition temp, *obj = &temp;
4271 if ( other == Py_None ) return true;
4272 if ( ! wxGBPosition_helper(other, &obj)) {
4273 PyErr_Clear();
4274 return true;
4275 }
4276 return self->operator!=(*obj);
4277 }
4278 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4279 self->SetRow(row);
4280 self->SetCol(col);
4281 }
4282 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4284 PyObject* tup = PyTuple_New(2);
4285 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4286 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4287 wxPyEndBlockThreads(blocked);
4288 return tup;
4289 }
4290 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4291 wxGBSpan temp, *obj = &temp;
4292 if ( other == Py_None ) return false;
4293 if ( ! wxGBSpan_helper(other, &obj) ) {
4294 PyErr_Clear();
4295 return false;
4296 }
4297 return self->operator==(*obj);
4298 }
4299 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4300 wxGBSpan temp, *obj = &temp;
4301 if ( other == Py_None ) return true;
4302 if ( ! wxGBSpan_helper(other, &obj)) {
4303 PyErr_Clear();
4304 return true;
4305 }
4306 return self->operator!=(*obj);
4307 }
4308 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4309 self->SetRowspan(rowspan);
4310 self->SetColspan(colspan);
4311 }
4312 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4314 PyObject* tup = PyTuple_New(2);
4315 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4316 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4317 wxPyEndBlockThreads(blocked);
4318 return tup;
4319 }
4320 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4321 wxPyUserData* data = NULL;
4322 if ( userData ) {
4323 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4324 data = new wxPyUserData(userData);
4325 wxPyEndBlockThreads(blocked);
4326 }
4327 return new wxGBSizerItem(window, pos, span, flag, border, data);
4328 }
4329 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4330 wxPyUserData* data = NULL;
4331 if ( userData ) {
4332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4333 data = new wxPyUserData(userData);
4334 wxPyEndBlockThreads(blocked);
4335 }
4336 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4337 }
4338 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4339 wxPyUserData* data = NULL;
4340 if ( userData ) {
4341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4342 data = new wxPyUserData(userData);
4343 wxPyEndBlockThreads(blocked);
4344 }
4345 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4346 }
4347 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4348 int row, col;
4349 self->GetEndPos(row, col);
4350 return wxGBPosition(row, col);
4351 }
4352 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4353
4354 wxPyUserData* data = NULL;
4355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4356 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4357 if ( userData && (info.window || info.sizer || info.gotSize) )
4358 data = new wxPyUserData(userData);
4359 if ( info.sizer )
4360 PyObject_SetAttrString(item,"thisown",Py_False);
4361 wxPyEndBlockThreads(blocked);
4362
4363 // Now call the real Add method if a valid item type was found
4364 if ( info.window )
4365 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4366 else if ( info.sizer )
4367 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4368 else if (info.gotSize)
4369 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4370 pos, span, flag, border, data);
4371 return NULL;
4372 }
4373
4374
4375 #ifdef __cplusplus
4376 extern "C" {
4377 #endif
4378 SWIGINTERN int EmptyString_set(PyObject *) {
4379 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4380 return 1;
4381 }
4382
4383
4384 SWIGINTERN PyObject *EmptyString_get(void) {
4385 PyObject *pyobj = 0;
4386
4387 {
4388 #if wxUSE_UNICODE
4389 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4390 #else
4391 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4392 #endif
4393 }
4394 return pyobj;
4395 }
4396
4397
4398 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4399 PyObject *resultobj = 0;
4400 wxObject *arg1 = (wxObject *) 0 ;
4401 wxString result;
4402 void *argp1 = 0 ;
4403 int res1 = 0 ;
4404 PyObject *swig_obj[1] ;
4405
4406 if (!args) SWIG_fail;
4407 swig_obj[0] = args;
4408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4409 if (!SWIG_IsOK(res1)) {
4410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4411 }
4412 arg1 = reinterpret_cast< wxObject * >(argp1);
4413 {
4414 PyThreadState* __tstate = wxPyBeginAllowThreads();
4415 result = wxObject_GetClassName(arg1);
4416 wxPyEndAllowThreads(__tstate);
4417 if (PyErr_Occurred()) SWIG_fail;
4418 }
4419 {
4420 #if wxUSE_UNICODE
4421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4422 #else
4423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4424 #endif
4425 }
4426 return resultobj;
4427 fail:
4428 return NULL;
4429 }
4430
4431
4432 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4433 PyObject *resultobj = 0;
4434 wxObject *arg1 = (wxObject *) 0 ;
4435 void *argp1 = 0 ;
4436 int res1 = 0 ;
4437 PyObject *swig_obj[1] ;
4438
4439 if (!args) SWIG_fail;
4440 swig_obj[0] = args;
4441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4442 if (!SWIG_IsOK(res1)) {
4443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4444 }
4445 arg1 = reinterpret_cast< wxObject * >(argp1);
4446 {
4447 PyThreadState* __tstate = wxPyBeginAllowThreads();
4448 wxObject_Destroy(arg1);
4449 wxPyEndAllowThreads(__tstate);
4450 if (PyErr_Occurred()) SWIG_fail;
4451 }
4452 resultobj = SWIG_Py_Void();
4453 return resultobj;
4454 fail:
4455 return NULL;
4456 }
4457
4458
4459 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4460 PyObject *obj;
4461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4462 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4463 return SWIG_Py_Void();
4464 }
4465
4466 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4467 PyObject *resultobj = 0;
4468 wxSize *arg1 = (wxSize *) 0 ;
4469 int arg2 ;
4470 void *argp1 = 0 ;
4471 int res1 = 0 ;
4472 int val2 ;
4473 int ecode2 = 0 ;
4474 PyObject *swig_obj[2] ;
4475
4476 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4478 if (!SWIG_IsOK(res1)) {
4479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4480 }
4481 arg1 = reinterpret_cast< wxSize * >(argp1);
4482 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4483 if (!SWIG_IsOK(ecode2)) {
4484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4485 }
4486 arg2 = static_cast< int >(val2);
4487 if (arg1) (arg1)->x = arg2;
4488
4489 resultobj = SWIG_Py_Void();
4490 return resultobj;
4491 fail:
4492 return NULL;
4493 }
4494
4495
4496 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4497 PyObject *resultobj = 0;
4498 wxSize *arg1 = (wxSize *) 0 ;
4499 int result;
4500 void *argp1 = 0 ;
4501 int res1 = 0 ;
4502 PyObject *swig_obj[1] ;
4503
4504 if (!args) SWIG_fail;
4505 swig_obj[0] = args;
4506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4507 if (!SWIG_IsOK(res1)) {
4508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4509 }
4510 arg1 = reinterpret_cast< wxSize * >(argp1);
4511 result = (int) ((arg1)->x);
4512 resultobj = SWIG_From_int(static_cast< int >(result));
4513 return resultobj;
4514 fail:
4515 return NULL;
4516 }
4517
4518
4519 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4520 PyObject *resultobj = 0;
4521 wxSize *arg1 = (wxSize *) 0 ;
4522 int arg2 ;
4523 void *argp1 = 0 ;
4524 int res1 = 0 ;
4525 int val2 ;
4526 int ecode2 = 0 ;
4527 PyObject *swig_obj[2] ;
4528
4529 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4531 if (!SWIG_IsOK(res1)) {
4532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4533 }
4534 arg1 = reinterpret_cast< wxSize * >(argp1);
4535 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4536 if (!SWIG_IsOK(ecode2)) {
4537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4538 }
4539 arg2 = static_cast< int >(val2);
4540 if (arg1) (arg1)->y = arg2;
4541
4542 resultobj = SWIG_Py_Void();
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550 PyObject *resultobj = 0;
4551 wxSize *arg1 = (wxSize *) 0 ;
4552 int result;
4553 void *argp1 = 0 ;
4554 int res1 = 0 ;
4555 PyObject *swig_obj[1] ;
4556
4557 if (!args) SWIG_fail;
4558 swig_obj[0] = args;
4559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4560 if (!SWIG_IsOK(res1)) {
4561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4562 }
4563 arg1 = reinterpret_cast< wxSize * >(argp1);
4564 result = (int) ((arg1)->y);
4565 resultobj = SWIG_From_int(static_cast< int >(result));
4566 return resultobj;
4567 fail:
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4573 PyObject *resultobj = 0;
4574 int arg1 = (int) 0 ;
4575 int arg2 = (int) 0 ;
4576 wxSize *result = 0 ;
4577 int val1 ;
4578 int ecode1 = 0 ;
4579 int val2 ;
4580 int ecode2 = 0 ;
4581 PyObject * obj0 = 0 ;
4582 PyObject * obj1 = 0 ;
4583 char * kwnames[] = {
4584 (char *) "w",(char *) "h", NULL
4585 };
4586
4587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4588 if (obj0) {
4589 ecode1 = SWIG_AsVal_int(obj0, &val1);
4590 if (!SWIG_IsOK(ecode1)) {
4591 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4592 }
4593 arg1 = static_cast< int >(val1);
4594 }
4595 if (obj1) {
4596 ecode2 = SWIG_AsVal_int(obj1, &val2);
4597 if (!SWIG_IsOK(ecode2)) {
4598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4599 }
4600 arg2 = static_cast< int >(val2);
4601 }
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 result = (wxSize *)new wxSize(arg1,arg2);
4605 wxPyEndAllowThreads(__tstate);
4606 if (PyErr_Occurred()) SWIG_fail;
4607 }
4608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4616 PyObject *resultobj = 0;
4617 wxSize *arg1 = (wxSize *) 0 ;
4618 void *argp1 = 0 ;
4619 int res1 = 0 ;
4620 PyObject *swig_obj[1] ;
4621
4622 if (!args) SWIG_fail;
4623 swig_obj[0] = args;
4624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4625 if (!SWIG_IsOK(res1)) {
4626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4627 }
4628 arg1 = reinterpret_cast< wxSize * >(argp1);
4629 {
4630 PyThreadState* __tstate = wxPyBeginAllowThreads();
4631 delete arg1;
4632
4633 wxPyEndAllowThreads(__tstate);
4634 if (PyErr_Occurred()) SWIG_fail;
4635 }
4636 resultobj = SWIG_Py_Void();
4637 return resultobj;
4638 fail:
4639 return NULL;
4640 }
4641
4642
4643 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4644 PyObject *resultobj = 0;
4645 wxSize *arg1 = (wxSize *) 0 ;
4646 PyObject *arg2 = (PyObject *) 0 ;
4647 bool result;
4648 void *argp1 = 0 ;
4649 int res1 = 0 ;
4650 PyObject * obj0 = 0 ;
4651 PyObject * obj1 = 0 ;
4652 char * kwnames[] = {
4653 (char *) "self",(char *) "other", NULL
4654 };
4655
4656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4658 if (!SWIG_IsOK(res1)) {
4659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4660 }
4661 arg1 = reinterpret_cast< wxSize * >(argp1);
4662 arg2 = obj1;
4663 {
4664 result = (bool)wxSize___eq__(arg1,arg2);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 {
4668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4669 }
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4677 PyObject *resultobj = 0;
4678 wxSize *arg1 = (wxSize *) 0 ;
4679 PyObject *arg2 = (PyObject *) 0 ;
4680 bool result;
4681 void *argp1 = 0 ;
4682 int res1 = 0 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char * kwnames[] = {
4686 (char *) "self",(char *) "other", NULL
4687 };
4688
4689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4691 if (!SWIG_IsOK(res1)) {
4692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4693 }
4694 arg1 = reinterpret_cast< wxSize * >(argp1);
4695 arg2 = obj1;
4696 {
4697 result = (bool)wxSize___ne__(arg1,arg2);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 {
4701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4702 }
4703 return resultobj;
4704 fail:
4705 return NULL;
4706 }
4707
4708
4709 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4710 PyObject *resultobj = 0;
4711 wxSize *arg1 = (wxSize *) 0 ;
4712 wxSize *arg2 = 0 ;
4713 wxSize result;
4714 void *argp1 = 0 ;
4715 int res1 = 0 ;
4716 wxSize temp2 ;
4717 PyObject * obj0 = 0 ;
4718 PyObject * obj1 = 0 ;
4719 char * kwnames[] = {
4720 (char *) "self",(char *) "sz", NULL
4721 };
4722
4723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4727 }
4728 arg1 = reinterpret_cast< wxSize * >(argp1);
4729 {
4730 arg2 = &temp2;
4731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4732 }
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (arg1)->operator +((wxSize const &)*arg2);
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4740 return resultobj;
4741 fail:
4742 return NULL;
4743 }
4744
4745
4746 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4747 PyObject *resultobj = 0;
4748 wxSize *arg1 = (wxSize *) 0 ;
4749 wxSize *arg2 = 0 ;
4750 wxSize result;
4751 void *argp1 = 0 ;
4752 int res1 = 0 ;
4753 wxSize temp2 ;
4754 PyObject * obj0 = 0 ;
4755 PyObject * obj1 = 0 ;
4756 char * kwnames[] = {
4757 (char *) "self",(char *) "sz", NULL
4758 };
4759
4760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4762 if (!SWIG_IsOK(res1)) {
4763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4764 }
4765 arg1 = reinterpret_cast< wxSize * >(argp1);
4766 {
4767 arg2 = &temp2;
4768 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (arg1)->operator -((wxSize const &)*arg2);
4773 wxPyEndAllowThreads(__tstate);
4774 if (PyErr_Occurred()) SWIG_fail;
4775 }
4776 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4777 return resultobj;
4778 fail:
4779 return NULL;
4780 }
4781
4782
4783 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4784 PyObject *resultobj = 0;
4785 wxSize *arg1 = (wxSize *) 0 ;
4786 wxSize *arg2 = 0 ;
4787 void *argp1 = 0 ;
4788 int res1 = 0 ;
4789 wxSize temp2 ;
4790 PyObject * obj0 = 0 ;
4791 PyObject * obj1 = 0 ;
4792 char * kwnames[] = {
4793 (char *) "self",(char *) "sz", NULL
4794 };
4795
4796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4798 if (!SWIG_IsOK(res1)) {
4799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4800 }
4801 arg1 = reinterpret_cast< wxSize * >(argp1);
4802 {
4803 arg2 = &temp2;
4804 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4805 }
4806 {
4807 PyThreadState* __tstate = wxPyBeginAllowThreads();
4808 (arg1)->IncTo((wxSize const &)*arg2);
4809 wxPyEndAllowThreads(__tstate);
4810 if (PyErr_Occurred()) SWIG_fail;
4811 }
4812 resultobj = SWIG_Py_Void();
4813 return resultobj;
4814 fail:
4815 return NULL;
4816 }
4817
4818
4819 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4820 PyObject *resultobj = 0;
4821 wxSize *arg1 = (wxSize *) 0 ;
4822 wxSize *arg2 = 0 ;
4823 void *argp1 = 0 ;
4824 int res1 = 0 ;
4825 wxSize temp2 ;
4826 PyObject * obj0 = 0 ;
4827 PyObject * obj1 = 0 ;
4828 char * kwnames[] = {
4829 (char *) "self",(char *) "sz", NULL
4830 };
4831
4832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4834 if (!SWIG_IsOK(res1)) {
4835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4836 }
4837 arg1 = reinterpret_cast< wxSize * >(argp1);
4838 {
4839 arg2 = &temp2;
4840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4841 }
4842 {
4843 PyThreadState* __tstate = wxPyBeginAllowThreads();
4844 (arg1)->DecTo((wxSize const &)*arg2);
4845 wxPyEndAllowThreads(__tstate);
4846 if (PyErr_Occurred()) SWIG_fail;
4847 }
4848 resultobj = SWIG_Py_Void();
4849 return resultobj;
4850 fail:
4851 return NULL;
4852 }
4853
4854
4855 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4856 PyObject *resultobj = 0;
4857 wxSize *arg1 = (wxSize *) 0 ;
4858 float arg2 ;
4859 float arg3 ;
4860 void *argp1 = 0 ;
4861 int res1 = 0 ;
4862 float val2 ;
4863 int ecode2 = 0 ;
4864 float val3 ;
4865 int ecode3 = 0 ;
4866 PyObject * obj0 = 0 ;
4867 PyObject * obj1 = 0 ;
4868 PyObject * obj2 = 0 ;
4869 char * kwnames[] = {
4870 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4871 };
4872
4873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4875 if (!SWIG_IsOK(res1)) {
4876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4877 }
4878 arg1 = reinterpret_cast< wxSize * >(argp1);
4879 ecode2 = SWIG_AsVal_float(obj1, &val2);
4880 if (!SWIG_IsOK(ecode2)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4882 }
4883 arg2 = static_cast< float >(val2);
4884 ecode3 = SWIG_AsVal_float(obj2, &val3);
4885 if (!SWIG_IsOK(ecode3)) {
4886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4887 }
4888 arg3 = static_cast< float >(val3);
4889 {
4890 PyThreadState* __tstate = wxPyBeginAllowThreads();
4891 (arg1)->Scale(arg2,arg3);
4892 wxPyEndAllowThreads(__tstate);
4893 if (PyErr_Occurred()) SWIG_fail;
4894 }
4895 resultobj = SWIG_Py_Void();
4896 return resultobj;
4897 fail:
4898 return NULL;
4899 }
4900
4901
4902 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4903 PyObject *resultobj = 0;
4904 wxSize *arg1 = (wxSize *) 0 ;
4905 int arg2 ;
4906 int arg3 ;
4907 void *argp1 = 0 ;
4908 int res1 = 0 ;
4909 int val2 ;
4910 int ecode2 = 0 ;
4911 int val3 ;
4912 int ecode3 = 0 ;
4913 PyObject * obj0 = 0 ;
4914 PyObject * obj1 = 0 ;
4915 PyObject * obj2 = 0 ;
4916 char * kwnames[] = {
4917 (char *) "self",(char *) "w",(char *) "h", NULL
4918 };
4919
4920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4922 if (!SWIG_IsOK(res1)) {
4923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4924 }
4925 arg1 = reinterpret_cast< wxSize * >(argp1);
4926 ecode2 = SWIG_AsVal_int(obj1, &val2);
4927 if (!SWIG_IsOK(ecode2)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4929 }
4930 arg2 = static_cast< int >(val2);
4931 ecode3 = SWIG_AsVal_int(obj2, &val3);
4932 if (!SWIG_IsOK(ecode3)) {
4933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4934 }
4935 arg3 = static_cast< int >(val3);
4936 {
4937 PyThreadState* __tstate = wxPyBeginAllowThreads();
4938 (arg1)->Set(arg2,arg3);
4939 wxPyEndAllowThreads(__tstate);
4940 if (PyErr_Occurred()) SWIG_fail;
4941 }
4942 resultobj = SWIG_Py_Void();
4943 return resultobj;
4944 fail:
4945 return NULL;
4946 }
4947
4948
4949 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4950 PyObject *resultobj = 0;
4951 wxSize *arg1 = (wxSize *) 0 ;
4952 int arg2 ;
4953 void *argp1 = 0 ;
4954 int res1 = 0 ;
4955 int val2 ;
4956 int ecode2 = 0 ;
4957 PyObject * obj0 = 0 ;
4958 PyObject * obj1 = 0 ;
4959 char * kwnames[] = {
4960 (char *) "self",(char *) "w", NULL
4961 };
4962
4963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4965 if (!SWIG_IsOK(res1)) {
4966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4967 }
4968 arg1 = reinterpret_cast< wxSize * >(argp1);
4969 ecode2 = SWIG_AsVal_int(obj1, &val2);
4970 if (!SWIG_IsOK(ecode2)) {
4971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4972 }
4973 arg2 = static_cast< int >(val2);
4974 {
4975 PyThreadState* __tstate = wxPyBeginAllowThreads();
4976 (arg1)->SetWidth(arg2);
4977 wxPyEndAllowThreads(__tstate);
4978 if (PyErr_Occurred()) SWIG_fail;
4979 }
4980 resultobj = SWIG_Py_Void();
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj = 0;
4989 wxSize *arg1 = (wxSize *) 0 ;
4990 int arg2 ;
4991 void *argp1 = 0 ;
4992 int res1 = 0 ;
4993 int val2 ;
4994 int ecode2 = 0 ;
4995 PyObject * obj0 = 0 ;
4996 PyObject * obj1 = 0 ;
4997 char * kwnames[] = {
4998 (char *) "self",(char *) "h", NULL
4999 };
5000
5001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5003 if (!SWIG_IsOK(res1)) {
5004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5005 }
5006 arg1 = reinterpret_cast< wxSize * >(argp1);
5007 ecode2 = SWIG_AsVal_int(obj1, &val2);
5008 if (!SWIG_IsOK(ecode2)) {
5009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5010 }
5011 arg2 = static_cast< int >(val2);
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 (arg1)->SetHeight(arg2);
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 resultobj = SWIG_Py_Void();
5019 return resultobj;
5020 fail:
5021 return NULL;
5022 }
5023
5024
5025 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026 PyObject *resultobj = 0;
5027 wxSize *arg1 = (wxSize *) 0 ;
5028 int result;
5029 void *argp1 = 0 ;
5030 int res1 = 0 ;
5031 PyObject *swig_obj[1] ;
5032
5033 if (!args) SWIG_fail;
5034 swig_obj[0] = args;
5035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5036 if (!SWIG_IsOK(res1)) {
5037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5038 }
5039 arg1 = reinterpret_cast< wxSize * >(argp1);
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (int)((wxSize const *)arg1)->GetWidth();
5043 wxPyEndAllowThreads(__tstate);
5044 if (PyErr_Occurred()) SWIG_fail;
5045 }
5046 resultobj = SWIG_From_int(static_cast< int >(result));
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5054 PyObject *resultobj = 0;
5055 wxSize *arg1 = (wxSize *) 0 ;
5056 int result;
5057 void *argp1 = 0 ;
5058 int res1 = 0 ;
5059 PyObject *swig_obj[1] ;
5060
5061 if (!args) SWIG_fail;
5062 swig_obj[0] = args;
5063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5064 if (!SWIG_IsOK(res1)) {
5065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5066 }
5067 arg1 = reinterpret_cast< wxSize * >(argp1);
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 result = (int)((wxSize const *)arg1)->GetHeight();
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_From_int(static_cast< int >(result));
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 bool result;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 PyObject *swig_obj[1] ;
5088
5089 if (!args) SWIG_fail;
5090 swig_obj[0] = args;
5091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5094 }
5095 arg1 = reinterpret_cast< wxSize * >(argp1);
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 {
5103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5104 }
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj = 0;
5113 wxSize *arg1 = (wxSize *) 0 ;
5114 wxSize *arg2 = 0 ;
5115 void *argp1 = 0 ;
5116 int res1 = 0 ;
5117 wxSize temp2 ;
5118 PyObject * obj0 = 0 ;
5119 PyObject * obj1 = 0 ;
5120 char * kwnames[] = {
5121 (char *) "self",(char *) "size", NULL
5122 };
5123
5124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5128 }
5129 arg1 = reinterpret_cast< wxSize * >(argp1);
5130 {
5131 arg2 = &temp2;
5132 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5133 }
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 (arg1)->SetDefaults((wxSize const &)*arg2);
5137 wxPyEndAllowThreads(__tstate);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 resultobj = SWIG_Py_Void();
5141 return resultobj;
5142 fail:
5143 return NULL;
5144 }
5145
5146
5147 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5148 PyObject *resultobj = 0;
5149 wxSize *arg1 = (wxSize *) 0 ;
5150 PyObject *result = 0 ;
5151 void *argp1 = 0 ;
5152 int res1 = 0 ;
5153 PyObject *swig_obj[1] ;
5154
5155 if (!args) SWIG_fail;
5156 swig_obj[0] = args;
5157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5158 if (!SWIG_IsOK(res1)) {
5159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5160 }
5161 arg1 = reinterpret_cast< wxSize * >(argp1);
5162 {
5163 PyThreadState* __tstate = wxPyBeginAllowThreads();
5164 result = (PyObject *)wxSize_Get(arg1);
5165 wxPyEndAllowThreads(__tstate);
5166 if (PyErr_Occurred()) SWIG_fail;
5167 }
5168 resultobj = result;
5169 return resultobj;
5170 fail:
5171 return NULL;
5172 }
5173
5174
5175 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5176 PyObject *obj;
5177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5178 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5179 return SWIG_Py_Void();
5180 }
5181
5182 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 return SWIG_Python_InitShadowInstance(args);
5184 }
5185
5186 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5187 PyObject *resultobj = 0;
5188 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5189 double arg2 ;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 double val2 ;
5193 int ecode2 = 0 ;
5194 PyObject *swig_obj[2] ;
5195
5196 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5198 if (!SWIG_IsOK(res1)) {
5199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5200 }
5201 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5202 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5203 if (!SWIG_IsOK(ecode2)) {
5204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5205 }
5206 arg2 = static_cast< double >(val2);
5207 if (arg1) (arg1)->x = arg2;
5208
5209 resultobj = SWIG_Py_Void();
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5217 PyObject *resultobj = 0;
5218 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5219 double result;
5220 void *argp1 = 0 ;
5221 int res1 = 0 ;
5222 PyObject *swig_obj[1] ;
5223
5224 if (!args) SWIG_fail;
5225 swig_obj[0] = args;
5226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5227 if (!SWIG_IsOK(res1)) {
5228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5229 }
5230 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5231 result = (double) ((arg1)->x);
5232 resultobj = SWIG_From_double(static_cast< double >(result));
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5240 PyObject *resultobj = 0;
5241 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5242 double arg2 ;
5243 void *argp1 = 0 ;
5244 int res1 = 0 ;
5245 double val2 ;
5246 int ecode2 = 0 ;
5247 PyObject *swig_obj[2] ;
5248
5249 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5251 if (!SWIG_IsOK(res1)) {
5252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5253 }
5254 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5255 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5256 if (!SWIG_IsOK(ecode2)) {
5257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5258 }
5259 arg2 = static_cast< double >(val2);
5260 if (arg1) (arg1)->y = arg2;
5261
5262 resultobj = SWIG_Py_Void();
5263 return resultobj;
5264 fail:
5265 return NULL;
5266 }
5267
5268
5269 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5270 PyObject *resultobj = 0;
5271 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5272 double result;
5273 void *argp1 = 0 ;
5274 int res1 = 0 ;
5275 PyObject *swig_obj[1] ;
5276
5277 if (!args) SWIG_fail;
5278 swig_obj[0] = args;
5279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5280 if (!SWIG_IsOK(res1)) {
5281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5282 }
5283 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5284 result = (double) ((arg1)->y);
5285 resultobj = SWIG_From_double(static_cast< double >(result));
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj = 0;
5294 double arg1 = (double) 0.0 ;
5295 double arg2 = (double) 0.0 ;
5296 wxRealPoint *result = 0 ;
5297 double val1 ;
5298 int ecode1 = 0 ;
5299 double val2 ;
5300 int ecode2 = 0 ;
5301 PyObject * obj0 = 0 ;
5302 PyObject * obj1 = 0 ;
5303 char * kwnames[] = {
5304 (char *) "x",(char *) "y", NULL
5305 };
5306
5307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5308 if (obj0) {
5309 ecode1 = SWIG_AsVal_double(obj0, &val1);
5310 if (!SWIG_IsOK(ecode1)) {
5311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5312 }
5313 arg1 = static_cast< double >(val1);
5314 }
5315 if (obj1) {
5316 ecode2 = SWIG_AsVal_double(obj1, &val2);
5317 if (!SWIG_IsOK(ecode2)) {
5318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5319 }
5320 arg2 = static_cast< double >(val2);
5321 }
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5329 return resultobj;
5330 fail:
5331 return NULL;
5332 }
5333
5334
5335 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5336 PyObject *resultobj = 0;
5337 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 PyObject *swig_obj[1] ;
5341
5342 if (!args) SWIG_fail;
5343 swig_obj[0] = args;
5344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5347 }
5348 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 delete arg1;
5352
5353 wxPyEndAllowThreads(__tstate);
5354 if (PyErr_Occurred()) SWIG_fail;
5355 }
5356 resultobj = SWIG_Py_Void();
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj = 0;
5365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5366 PyObject *arg2 = (PyObject *) 0 ;
5367 bool result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 PyObject * obj0 = 0 ;
5371 PyObject * obj1 = 0 ;
5372 char * kwnames[] = {
5373 (char *) "self",(char *) "other", NULL
5374 };
5375
5376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5378 if (!SWIG_IsOK(res1)) {
5379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5380 }
5381 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5382 arg2 = obj1;
5383 {
5384 result = (bool)wxRealPoint___eq__(arg1,arg2);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 {
5388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5389 }
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5397 PyObject *resultobj = 0;
5398 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5399 PyObject *arg2 = (PyObject *) 0 ;
5400 bool result;
5401 void *argp1 = 0 ;
5402 int res1 = 0 ;
5403 PyObject * obj0 = 0 ;
5404 PyObject * obj1 = 0 ;
5405 char * kwnames[] = {
5406 (char *) "self",(char *) "other", NULL
5407 };
5408
5409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5411 if (!SWIG_IsOK(res1)) {
5412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5413 }
5414 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5415 arg2 = obj1;
5416 {
5417 result = (bool)wxRealPoint___ne__(arg1,arg2);
5418 if (PyErr_Occurred()) SWIG_fail;
5419 }
5420 {
5421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5422 }
5423 return resultobj;
5424 fail:
5425 return NULL;
5426 }
5427
5428
5429 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5430 PyObject *resultobj = 0;
5431 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5432 wxRealPoint *arg2 = 0 ;
5433 wxRealPoint result;
5434 void *argp1 = 0 ;
5435 int res1 = 0 ;
5436 wxRealPoint temp2 ;
5437 PyObject * obj0 = 0 ;
5438 PyObject * obj1 = 0 ;
5439 char * kwnames[] = {
5440 (char *) "self",(char *) "pt", NULL
5441 };
5442
5443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5445 if (!SWIG_IsOK(res1)) {
5446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5447 }
5448 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5449 {
5450 arg2 = &temp2;
5451 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5452 }
5453 {
5454 PyThreadState* __tstate = wxPyBeginAllowThreads();
5455 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5460 return resultobj;
5461 fail:
5462 return NULL;
5463 }
5464
5465
5466 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5467 PyObject *resultobj = 0;
5468 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5469 wxRealPoint *arg2 = 0 ;
5470 wxRealPoint result;
5471 void *argp1 = 0 ;
5472 int res1 = 0 ;
5473 wxRealPoint temp2 ;
5474 PyObject * obj0 = 0 ;
5475 PyObject * obj1 = 0 ;
5476 char * kwnames[] = {
5477 (char *) "self",(char *) "pt", NULL
5478 };
5479
5480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5482 if (!SWIG_IsOK(res1)) {
5483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5484 }
5485 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5486 {
5487 arg2 = &temp2;
5488 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5489 }
5490 {
5491 PyThreadState* __tstate = wxPyBeginAllowThreads();
5492 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5493 wxPyEndAllowThreads(__tstate);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5497 return resultobj;
5498 fail:
5499 return NULL;
5500 }
5501
5502
5503 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5504 PyObject *resultobj = 0;
5505 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5506 double arg2 ;
5507 double arg3 ;
5508 void *argp1 = 0 ;
5509 int res1 = 0 ;
5510 double val2 ;
5511 int ecode2 = 0 ;
5512 double val3 ;
5513 int ecode3 = 0 ;
5514 PyObject * obj0 = 0 ;
5515 PyObject * obj1 = 0 ;
5516 PyObject * obj2 = 0 ;
5517 char * kwnames[] = {
5518 (char *) "self",(char *) "x",(char *) "y", NULL
5519 };
5520
5521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5523 if (!SWIG_IsOK(res1)) {
5524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5525 }
5526 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5527 ecode2 = SWIG_AsVal_double(obj1, &val2);
5528 if (!SWIG_IsOK(ecode2)) {
5529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5530 }
5531 arg2 = static_cast< double >(val2);
5532 ecode3 = SWIG_AsVal_double(obj2, &val3);
5533 if (!SWIG_IsOK(ecode3)) {
5534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5535 }
5536 arg3 = static_cast< double >(val3);
5537 {
5538 PyThreadState* __tstate = wxPyBeginAllowThreads();
5539 wxRealPoint_Set(arg1,arg2,arg3);
5540 wxPyEndAllowThreads(__tstate);
5541 if (PyErr_Occurred()) SWIG_fail;
5542 }
5543 resultobj = SWIG_Py_Void();
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5551 PyObject *resultobj = 0;
5552 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5553 PyObject *result = 0 ;
5554 void *argp1 = 0 ;
5555 int res1 = 0 ;
5556 PyObject *swig_obj[1] ;
5557
5558 if (!args) SWIG_fail;
5559 swig_obj[0] = args;
5560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5561 if (!SWIG_IsOK(res1)) {
5562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5563 }
5564 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5565 {
5566 PyThreadState* __tstate = wxPyBeginAllowThreads();
5567 result = (PyObject *)wxRealPoint_Get(arg1);
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 resultobj = result;
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579 PyObject *obj;
5580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5581 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5582 return SWIG_Py_Void();
5583 }
5584
5585 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 return SWIG_Python_InitShadowInstance(args);
5587 }
5588
5589 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5590 PyObject *resultobj = 0;
5591 wxPoint *arg1 = (wxPoint *) 0 ;
5592 int arg2 ;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 int val2 ;
5596 int ecode2 = 0 ;
5597 PyObject *swig_obj[2] ;
5598
5599 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5601 if (!SWIG_IsOK(res1)) {
5602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5603 }
5604 arg1 = reinterpret_cast< wxPoint * >(argp1);
5605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5606 if (!SWIG_IsOK(ecode2)) {
5607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5608 }
5609 arg2 = static_cast< int >(val2);
5610 if (arg1) (arg1)->x = arg2;
5611
5612 resultobj = SWIG_Py_Void();
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5620 PyObject *resultobj = 0;
5621 wxPoint *arg1 = (wxPoint *) 0 ;
5622 int result;
5623 void *argp1 = 0 ;
5624 int res1 = 0 ;
5625 PyObject *swig_obj[1] ;
5626
5627 if (!args) SWIG_fail;
5628 swig_obj[0] = args;
5629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5630 if (!SWIG_IsOK(res1)) {
5631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5632 }
5633 arg1 = reinterpret_cast< wxPoint * >(argp1);
5634 result = (int) ((arg1)->x);
5635 resultobj = SWIG_From_int(static_cast< int >(result));
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5643 PyObject *resultobj = 0;
5644 wxPoint *arg1 = (wxPoint *) 0 ;
5645 int arg2 ;
5646 void *argp1 = 0 ;
5647 int res1 = 0 ;
5648 int val2 ;
5649 int ecode2 = 0 ;
5650 PyObject *swig_obj[2] ;
5651
5652 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5654 if (!SWIG_IsOK(res1)) {
5655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5656 }
5657 arg1 = reinterpret_cast< wxPoint * >(argp1);
5658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5659 if (!SWIG_IsOK(ecode2)) {
5660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5661 }
5662 arg2 = static_cast< int >(val2);
5663 if (arg1) (arg1)->y = arg2;
5664
5665 resultobj = SWIG_Py_Void();
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5673 PyObject *resultobj = 0;
5674 wxPoint *arg1 = (wxPoint *) 0 ;
5675 int result;
5676 void *argp1 = 0 ;
5677 int res1 = 0 ;
5678 PyObject *swig_obj[1] ;
5679
5680 if (!args) SWIG_fail;
5681 swig_obj[0] = args;
5682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5683 if (!SWIG_IsOK(res1)) {
5684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5685 }
5686 arg1 = reinterpret_cast< wxPoint * >(argp1);
5687 result = (int) ((arg1)->y);
5688 resultobj = SWIG_From_int(static_cast< int >(result));
5689 return resultobj;
5690 fail:
5691 return NULL;
5692 }
5693
5694
5695 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5696 PyObject *resultobj = 0;
5697 int arg1 = (int) 0 ;
5698 int arg2 = (int) 0 ;
5699 wxPoint *result = 0 ;
5700 int val1 ;
5701 int ecode1 = 0 ;
5702 int val2 ;
5703 int ecode2 = 0 ;
5704 PyObject * obj0 = 0 ;
5705 PyObject * obj1 = 0 ;
5706 char * kwnames[] = {
5707 (char *) "x",(char *) "y", NULL
5708 };
5709
5710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5711 if (obj0) {
5712 ecode1 = SWIG_AsVal_int(obj0, &val1);
5713 if (!SWIG_IsOK(ecode1)) {
5714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5715 }
5716 arg1 = static_cast< int >(val1);
5717 }
5718 if (obj1) {
5719 ecode2 = SWIG_AsVal_int(obj1, &val2);
5720 if (!SWIG_IsOK(ecode2)) {
5721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5722 }
5723 arg2 = static_cast< int >(val2);
5724 }
5725 {
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 result = (wxPoint *)new wxPoint(arg1,arg2);
5728 wxPyEndAllowThreads(__tstate);
5729 if (PyErr_Occurred()) SWIG_fail;
5730 }
5731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5732 return resultobj;
5733 fail:
5734 return NULL;
5735 }
5736
5737
5738 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5739 PyObject *resultobj = 0;
5740 wxPoint *arg1 = (wxPoint *) 0 ;
5741 void *argp1 = 0 ;
5742 int res1 = 0 ;
5743 PyObject *swig_obj[1] ;
5744
5745 if (!args) SWIG_fail;
5746 swig_obj[0] = args;
5747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5748 if (!SWIG_IsOK(res1)) {
5749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5750 }
5751 arg1 = reinterpret_cast< wxPoint * >(argp1);
5752 {
5753 PyThreadState* __tstate = wxPyBeginAllowThreads();
5754 delete arg1;
5755
5756 wxPyEndAllowThreads(__tstate);
5757 if (PyErr_Occurred()) SWIG_fail;
5758 }
5759 resultobj = SWIG_Py_Void();
5760 return resultobj;
5761 fail:
5762 return NULL;
5763 }
5764
5765
5766 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5767 PyObject *resultobj = 0;
5768 wxPoint *arg1 = (wxPoint *) 0 ;
5769 PyObject *arg2 = (PyObject *) 0 ;
5770 bool result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 PyObject * obj0 = 0 ;
5774 PyObject * obj1 = 0 ;
5775 char * kwnames[] = {
5776 (char *) "self",(char *) "other", NULL
5777 };
5778
5779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5781 if (!SWIG_IsOK(res1)) {
5782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5783 }
5784 arg1 = reinterpret_cast< wxPoint * >(argp1);
5785 arg2 = obj1;
5786 {
5787 result = (bool)wxPoint___eq__(arg1,arg2);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 {
5791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5792 }
5793 return resultobj;
5794 fail:
5795 return NULL;
5796 }
5797
5798
5799 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5800 PyObject *resultobj = 0;
5801 wxPoint *arg1 = (wxPoint *) 0 ;
5802 PyObject *arg2 = (PyObject *) 0 ;
5803 bool result;
5804 void *argp1 = 0 ;
5805 int res1 = 0 ;
5806 PyObject * obj0 = 0 ;
5807 PyObject * obj1 = 0 ;
5808 char * kwnames[] = {
5809 (char *) "self",(char *) "other", NULL
5810 };
5811
5812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5814 if (!SWIG_IsOK(res1)) {
5815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5816 }
5817 arg1 = reinterpret_cast< wxPoint * >(argp1);
5818 arg2 = obj1;
5819 {
5820 result = (bool)wxPoint___ne__(arg1,arg2);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 {
5824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5825 }
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj = 0;
5834 wxPoint *arg1 = (wxPoint *) 0 ;
5835 wxPoint *arg2 = 0 ;
5836 wxPoint result;
5837 void *argp1 = 0 ;
5838 int res1 = 0 ;
5839 wxPoint temp2 ;
5840 PyObject * obj0 = 0 ;
5841 PyObject * obj1 = 0 ;
5842 char * kwnames[] = {
5843 (char *) "self",(char *) "pt", NULL
5844 };
5845
5846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5848 if (!SWIG_IsOK(res1)) {
5849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5850 }
5851 arg1 = reinterpret_cast< wxPoint * >(argp1);
5852 {
5853 arg2 = &temp2;
5854 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5855 }
5856 {
5857 PyThreadState* __tstate = wxPyBeginAllowThreads();
5858 result = (arg1)->operator +((wxPoint const &)*arg2);
5859 wxPyEndAllowThreads(__tstate);
5860 if (PyErr_Occurred()) SWIG_fail;
5861 }
5862 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5863 return resultobj;
5864 fail:
5865 return NULL;
5866 }
5867
5868
5869 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5870 PyObject *resultobj = 0;
5871 wxPoint *arg1 = (wxPoint *) 0 ;
5872 wxPoint *arg2 = 0 ;
5873 wxPoint result;
5874 void *argp1 = 0 ;
5875 int res1 = 0 ;
5876 wxPoint temp2 ;
5877 PyObject * obj0 = 0 ;
5878 PyObject * obj1 = 0 ;
5879 char * kwnames[] = {
5880 (char *) "self",(char *) "pt", NULL
5881 };
5882
5883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5885 if (!SWIG_IsOK(res1)) {
5886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5887 }
5888 arg1 = reinterpret_cast< wxPoint * >(argp1);
5889 {
5890 arg2 = &temp2;
5891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5892 }
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (arg1)->operator -((wxPoint const &)*arg2);
5896 wxPyEndAllowThreads(__tstate);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj = 0;
5908 wxPoint *arg1 = (wxPoint *) 0 ;
5909 wxPoint *arg2 = 0 ;
5910 wxPoint *result = 0 ;
5911 void *argp1 = 0 ;
5912 int res1 = 0 ;
5913 wxPoint temp2 ;
5914 PyObject * obj0 = 0 ;
5915 PyObject * obj1 = 0 ;
5916 char * kwnames[] = {
5917 (char *) "self",(char *) "pt", NULL
5918 };
5919
5920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5922 if (!SWIG_IsOK(res1)) {
5923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5924 }
5925 arg1 = reinterpret_cast< wxPoint * >(argp1);
5926 {
5927 arg2 = &temp2;
5928 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5929 }
5930 {
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 {
5933 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5934 result = (wxPoint *) &_result_ref;
5935 }
5936 wxPyEndAllowThreads(__tstate);
5937 if (PyErr_Occurred()) SWIG_fail;
5938 }
5939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5940 return resultobj;
5941 fail:
5942 return NULL;
5943 }
5944
5945
5946 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5947 PyObject *resultobj = 0;
5948 wxPoint *arg1 = (wxPoint *) 0 ;
5949 wxPoint *arg2 = 0 ;
5950 wxPoint *result = 0 ;
5951 void *argp1 = 0 ;
5952 int res1 = 0 ;
5953 wxPoint temp2 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 char * kwnames[] = {
5957 (char *) "self",(char *) "pt", NULL
5958 };
5959
5960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5962 if (!SWIG_IsOK(res1)) {
5963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5964 }
5965 arg1 = reinterpret_cast< wxPoint * >(argp1);
5966 {
5967 arg2 = &temp2;
5968 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5969 }
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 {
5973 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5974 result = (wxPoint *) &_result_ref;
5975 }
5976 wxPyEndAllowThreads(__tstate);
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj = 0;
5988 wxPoint *arg1 = (wxPoint *) 0 ;
5989 long arg2 ;
5990 long arg3 ;
5991 void *argp1 = 0 ;
5992 int res1 = 0 ;
5993 long val2 ;
5994 int ecode2 = 0 ;
5995 long val3 ;
5996 int ecode3 = 0 ;
5997 PyObject * obj0 = 0 ;
5998 PyObject * obj1 = 0 ;
5999 PyObject * obj2 = 0 ;
6000 char * kwnames[] = {
6001 (char *) "self",(char *) "x",(char *) "y", NULL
6002 };
6003
6004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6006 if (!SWIG_IsOK(res1)) {
6007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6008 }
6009 arg1 = reinterpret_cast< wxPoint * >(argp1);
6010 ecode2 = SWIG_AsVal_long(obj1, &val2);
6011 if (!SWIG_IsOK(ecode2)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6013 }
6014 arg2 = static_cast< long >(val2);
6015 ecode3 = SWIG_AsVal_long(obj2, &val3);
6016 if (!SWIG_IsOK(ecode3)) {
6017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6018 }
6019 arg3 = static_cast< long >(val3);
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 wxPoint_Set(arg1,arg2,arg3);
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_Py_Void();
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6034 PyObject *resultobj = 0;
6035 wxPoint *arg1 = (wxPoint *) 0 ;
6036 PyObject *result = 0 ;
6037 void *argp1 = 0 ;
6038 int res1 = 0 ;
6039 PyObject *swig_obj[1] ;
6040
6041 if (!args) SWIG_fail;
6042 swig_obj[0] = args;
6043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6044 if (!SWIG_IsOK(res1)) {
6045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6046 }
6047 arg1 = reinterpret_cast< wxPoint * >(argp1);
6048 {
6049 PyThreadState* __tstate = wxPyBeginAllowThreads();
6050 result = (PyObject *)wxPoint_Get(arg1);
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 resultobj = result;
6055 return resultobj;
6056 fail:
6057 return NULL;
6058 }
6059
6060
6061 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6062 PyObject *obj;
6063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6064 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6065 return SWIG_Py_Void();
6066 }
6067
6068 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6069 return SWIG_Python_InitShadowInstance(args);
6070 }
6071
6072 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj = 0;
6074 int arg1 = (int) 0 ;
6075 int arg2 = (int) 0 ;
6076 int arg3 = (int) 0 ;
6077 int arg4 = (int) 0 ;
6078 wxRect *result = 0 ;
6079 int val1 ;
6080 int ecode1 = 0 ;
6081 int val2 ;
6082 int ecode2 = 0 ;
6083 int val3 ;
6084 int ecode3 = 0 ;
6085 int val4 ;
6086 int ecode4 = 0 ;
6087 PyObject * obj0 = 0 ;
6088 PyObject * obj1 = 0 ;
6089 PyObject * obj2 = 0 ;
6090 PyObject * obj3 = 0 ;
6091 char * kwnames[] = {
6092 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6093 };
6094
6095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6096 if (obj0) {
6097 ecode1 = SWIG_AsVal_int(obj0, &val1);
6098 if (!SWIG_IsOK(ecode1)) {
6099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6100 }
6101 arg1 = static_cast< int >(val1);
6102 }
6103 if (obj1) {
6104 ecode2 = SWIG_AsVal_int(obj1, &val2);
6105 if (!SWIG_IsOK(ecode2)) {
6106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6107 }
6108 arg2 = static_cast< int >(val2);
6109 }
6110 if (obj2) {
6111 ecode3 = SWIG_AsVal_int(obj2, &val3);
6112 if (!SWIG_IsOK(ecode3)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6114 }
6115 arg3 = static_cast< int >(val3);
6116 }
6117 if (obj3) {
6118 ecode4 = SWIG_AsVal_int(obj3, &val4);
6119 if (!SWIG_IsOK(ecode4)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6121 }
6122 arg4 = static_cast< int >(val4);
6123 }
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj = 0;
6139 wxPoint *arg1 = 0 ;
6140 wxPoint *arg2 = 0 ;
6141 wxRect *result = 0 ;
6142 wxPoint temp1 ;
6143 wxPoint temp2 ;
6144 PyObject * obj0 = 0 ;
6145 PyObject * obj1 = 0 ;
6146 char * kwnames[] = {
6147 (char *) "topLeft",(char *) "bottomRight", NULL
6148 };
6149
6150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6151 {
6152 arg1 = &temp1;
6153 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6154 }
6155 {
6156 arg2 = &temp2;
6157 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6158 }
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj = 0;
6174 wxPoint *arg1 = 0 ;
6175 wxSize *arg2 = 0 ;
6176 wxRect *result = 0 ;
6177 wxPoint temp1 ;
6178 wxSize temp2 ;
6179 PyObject * obj0 = 0 ;
6180 PyObject * obj1 = 0 ;
6181 char * kwnames[] = {
6182 (char *) "pos",(char *) "size", NULL
6183 };
6184
6185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6186 {
6187 arg1 = &temp1;
6188 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6189 }
6190 {
6191 arg2 = &temp2;
6192 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6193 }
6194 {
6195 PyThreadState* __tstate = wxPyBeginAllowThreads();
6196 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj = 0;
6209 wxSize *arg1 = 0 ;
6210 wxRect *result = 0 ;
6211 wxSize temp1 ;
6212 PyObject * obj0 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "size", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6218 {
6219 arg1 = &temp1;
6220 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6221 }
6222 {
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6236 PyObject *resultobj = 0;
6237 wxRect *arg1 = (wxRect *) 0 ;
6238 void *argp1 = 0 ;
6239 int res1 = 0 ;
6240 PyObject *swig_obj[1] ;
6241
6242 if (!args) SWIG_fail;
6243 swig_obj[0] = args;
6244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6245 if (!SWIG_IsOK(res1)) {
6246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6247 }
6248 arg1 = reinterpret_cast< wxRect * >(argp1);
6249 {
6250 PyThreadState* __tstate = wxPyBeginAllowThreads();
6251 delete arg1;
6252
6253 wxPyEndAllowThreads(__tstate);
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 resultobj = SWIG_Py_Void();
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6264 PyObject *resultobj = 0;
6265 wxRect *arg1 = (wxRect *) 0 ;
6266 int result;
6267 void *argp1 = 0 ;
6268 int res1 = 0 ;
6269 PyObject *swig_obj[1] ;
6270
6271 if (!args) SWIG_fail;
6272 swig_obj[0] = args;
6273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6274 if (!SWIG_IsOK(res1)) {
6275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6276 }
6277 arg1 = reinterpret_cast< wxRect * >(argp1);
6278 {
6279 PyThreadState* __tstate = wxPyBeginAllowThreads();
6280 result = (int)((wxRect const *)arg1)->GetX();
6281 wxPyEndAllowThreads(__tstate);
6282 if (PyErr_Occurred()) SWIG_fail;
6283 }
6284 resultobj = SWIG_From_int(static_cast< int >(result));
6285 return resultobj;
6286 fail:
6287 return NULL;
6288 }
6289
6290
6291 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6292 PyObject *resultobj = 0;
6293 wxRect *arg1 = (wxRect *) 0 ;
6294 int arg2 ;
6295 void *argp1 = 0 ;
6296 int res1 = 0 ;
6297 int val2 ;
6298 int ecode2 = 0 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char * kwnames[] = {
6302 (char *) "self",(char *) "x", NULL
6303 };
6304
6305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6307 if (!SWIG_IsOK(res1)) {
6308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6309 }
6310 arg1 = reinterpret_cast< wxRect * >(argp1);
6311 ecode2 = SWIG_AsVal_int(obj1, &val2);
6312 if (!SWIG_IsOK(ecode2)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6314 }
6315 arg2 = static_cast< int >(val2);
6316 {
6317 PyThreadState* __tstate = wxPyBeginAllowThreads();
6318 (arg1)->SetX(arg2);
6319 wxPyEndAllowThreads(__tstate);
6320 if (PyErr_Occurred()) SWIG_fail;
6321 }
6322 resultobj = SWIG_Py_Void();
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6330 PyObject *resultobj = 0;
6331 wxRect *arg1 = (wxRect *) 0 ;
6332 int result;
6333 void *argp1 = 0 ;
6334 int res1 = 0 ;
6335 PyObject *swig_obj[1] ;
6336
6337 if (!args) SWIG_fail;
6338 swig_obj[0] = args;
6339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6342 }
6343 arg1 = reinterpret_cast< wxRect * >(argp1);
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 result = (int)(arg1)->GetY();
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 resultobj = SWIG_From_int(static_cast< int >(result));
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj = 0;
6359 wxRect *arg1 = (wxRect *) 0 ;
6360 int arg2 ;
6361 void *argp1 = 0 ;
6362 int res1 = 0 ;
6363 int val2 ;
6364 int ecode2 = 0 ;
6365 PyObject * obj0 = 0 ;
6366 PyObject * obj1 = 0 ;
6367 char * kwnames[] = {
6368 (char *) "self",(char *) "y", NULL
6369 };
6370
6371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6373 if (!SWIG_IsOK(res1)) {
6374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6375 }
6376 arg1 = reinterpret_cast< wxRect * >(argp1);
6377 ecode2 = SWIG_AsVal_int(obj1, &val2);
6378 if (!SWIG_IsOK(ecode2)) {
6379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6380 }
6381 arg2 = static_cast< int >(val2);
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 (arg1)->SetY(arg2);
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 resultobj = SWIG_Py_Void();
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6396 PyObject *resultobj = 0;
6397 wxRect *arg1 = (wxRect *) 0 ;
6398 int result;
6399 void *argp1 = 0 ;
6400 int res1 = 0 ;
6401 PyObject *swig_obj[1] ;
6402
6403 if (!args) SWIG_fail;
6404 swig_obj[0] = args;
6405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6406 if (!SWIG_IsOK(res1)) {
6407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6408 }
6409 arg1 = reinterpret_cast< wxRect * >(argp1);
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (int)((wxRect const *)arg1)->GetWidth();
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = SWIG_From_int(static_cast< int >(result));
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj = 0;
6425 wxRect *arg1 = (wxRect *) 0 ;
6426 int arg2 ;
6427 void *argp1 = 0 ;
6428 int res1 = 0 ;
6429 int val2 ;
6430 int ecode2 = 0 ;
6431 PyObject * obj0 = 0 ;
6432 PyObject * obj1 = 0 ;
6433 char * kwnames[] = {
6434 (char *) "self",(char *) "w", NULL
6435 };
6436
6437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6439 if (!SWIG_IsOK(res1)) {
6440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6441 }
6442 arg1 = reinterpret_cast< wxRect * >(argp1);
6443 ecode2 = SWIG_AsVal_int(obj1, &val2);
6444 if (!SWIG_IsOK(ecode2)) {
6445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6446 }
6447 arg2 = static_cast< int >(val2);
6448 {
6449 PyThreadState* __tstate = wxPyBeginAllowThreads();
6450 (arg1)->SetWidth(arg2);
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_Py_Void();
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6462 PyObject *resultobj = 0;
6463 wxRect *arg1 = (wxRect *) 0 ;
6464 int result;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 PyObject *swig_obj[1] ;
6468
6469 if (!args) SWIG_fail;
6470 swig_obj[0] = args;
6471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6474 }
6475 arg1 = reinterpret_cast< wxRect * >(argp1);
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (int)((wxRect const *)arg1)->GetHeight();
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 resultobj = SWIG_From_int(static_cast< int >(result));
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj = 0;
6491 wxRect *arg1 = (wxRect *) 0 ;
6492 int arg2 ;
6493 void *argp1 = 0 ;
6494 int res1 = 0 ;
6495 int val2 ;
6496 int ecode2 = 0 ;
6497 PyObject * obj0 = 0 ;
6498 PyObject * obj1 = 0 ;
6499 char * kwnames[] = {
6500 (char *) "self",(char *) "h", NULL
6501 };
6502
6503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6505 if (!SWIG_IsOK(res1)) {
6506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6507 }
6508 arg1 = reinterpret_cast< wxRect * >(argp1);
6509 ecode2 = SWIG_AsVal_int(obj1, &val2);
6510 if (!SWIG_IsOK(ecode2)) {
6511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6512 }
6513 arg2 = static_cast< int >(val2);
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 (arg1)->SetHeight(arg2);
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_Py_Void();
6521 return resultobj;
6522 fail:
6523 return NULL;
6524 }
6525
6526
6527 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6528 PyObject *resultobj = 0;
6529 wxRect *arg1 = (wxRect *) 0 ;
6530 wxPoint result;
6531 void *argp1 = 0 ;
6532 int res1 = 0 ;
6533 PyObject *swig_obj[1] ;
6534
6535 if (!args) SWIG_fail;
6536 swig_obj[0] = args;
6537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6540 }
6541 arg1 = reinterpret_cast< wxRect * >(argp1);
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 result = ((wxRect const *)arg1)->GetPosition();
6545 wxPyEndAllowThreads(__tstate);
6546 if (PyErr_Occurred()) SWIG_fail;
6547 }
6548 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6549 return resultobj;
6550 fail:
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj = 0;
6557 wxRect *arg1 = (wxRect *) 0 ;
6558 wxPoint *arg2 = 0 ;
6559 void *argp1 = 0 ;
6560 int res1 = 0 ;
6561 wxPoint temp2 ;
6562 PyObject * obj0 = 0 ;
6563 PyObject * obj1 = 0 ;
6564 char * kwnames[] = {
6565 (char *) "self",(char *) "p", NULL
6566 };
6567
6568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6570 if (!SWIG_IsOK(res1)) {
6571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6572 }
6573 arg1 = reinterpret_cast< wxRect * >(argp1);
6574 {
6575 arg2 = &temp2;
6576 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6577 }
6578 {
6579 PyThreadState* __tstate = wxPyBeginAllowThreads();
6580 (arg1)->SetPosition((wxPoint const &)*arg2);
6581 wxPyEndAllowThreads(__tstate);
6582 if (PyErr_Occurred()) SWIG_fail;
6583 }
6584 resultobj = SWIG_Py_Void();
6585 return resultobj;
6586 fail:
6587 return NULL;
6588 }
6589
6590
6591 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6592 PyObject *resultobj = 0;
6593 wxRect *arg1 = (wxRect *) 0 ;
6594 wxSize result;
6595 void *argp1 = 0 ;
6596 int res1 = 0 ;
6597 PyObject *swig_obj[1] ;
6598
6599 if (!args) SWIG_fail;
6600 swig_obj[0] = args;
6601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6602 if (!SWIG_IsOK(res1)) {
6603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6604 }
6605 arg1 = reinterpret_cast< wxRect * >(argp1);
6606 {
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 result = ((wxRect const *)arg1)->GetSize();
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj = 0;
6621 wxRect *arg1 = (wxRect *) 0 ;
6622 wxSize *arg2 = 0 ;
6623 void *argp1 = 0 ;
6624 int res1 = 0 ;
6625 wxSize temp2 ;
6626 PyObject * obj0 = 0 ;
6627 PyObject * obj1 = 0 ;
6628 char * kwnames[] = {
6629 (char *) "self",(char *) "s", NULL
6630 };
6631
6632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6634 if (!SWIG_IsOK(res1)) {
6635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6636 }
6637 arg1 = reinterpret_cast< wxRect * >(argp1);
6638 {
6639 arg2 = &temp2;
6640 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6641 }
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 (arg1)->SetSize((wxSize const &)*arg2);
6645 wxPyEndAllowThreads(__tstate);
6646 if (PyErr_Occurred()) SWIG_fail;
6647 }
6648 resultobj = SWIG_Py_Void();
6649 return resultobj;
6650 fail:
6651 return NULL;
6652 }
6653
6654
6655 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6656 PyObject *resultobj = 0;
6657 wxRect *arg1 = (wxRect *) 0 ;
6658 bool result;
6659 void *argp1 = 0 ;
6660 int res1 = 0 ;
6661 PyObject *swig_obj[1] ;
6662
6663 if (!args) SWIG_fail;
6664 swig_obj[0] = args;
6665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6666 if (!SWIG_IsOK(res1)) {
6667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6668 }
6669 arg1 = reinterpret_cast< wxRect * >(argp1);
6670 {
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 result = (bool)((wxRect const *)arg1)->IsEmpty();
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 {
6677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6678 }
6679 return resultobj;
6680 fail:
6681 return NULL;
6682 }
6683
6684
6685 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6686 PyObject *resultobj = 0;
6687 wxRect *arg1 = (wxRect *) 0 ;
6688 wxPoint result;
6689 void *argp1 = 0 ;
6690 int res1 = 0 ;
6691 PyObject *swig_obj[1] ;
6692
6693 if (!args) SWIG_fail;
6694 swig_obj[0] = args;
6695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6696 if (!SWIG_IsOK(res1)) {
6697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6698 }
6699 arg1 = reinterpret_cast< wxRect * >(argp1);
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 result = ((wxRect const *)arg1)->GetTopLeft();
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj = 0;
6715 wxRect *arg1 = (wxRect *) 0 ;
6716 wxPoint *arg2 = 0 ;
6717 void *argp1 = 0 ;
6718 int res1 = 0 ;
6719 wxPoint temp2 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 char * kwnames[] = {
6723 (char *) "self",(char *) "p", NULL
6724 };
6725
6726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6730 }
6731 arg1 = reinterpret_cast< wxRect * >(argp1);
6732 {
6733 arg2 = &temp2;
6734 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 resultobj = SWIG_Py_Void();
6743 return resultobj;
6744 fail:
6745 return NULL;
6746 }
6747
6748
6749 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6750 PyObject *resultobj = 0;
6751 wxRect *arg1 = (wxRect *) 0 ;
6752 wxPoint result;
6753 void *argp1 = 0 ;
6754 int res1 = 0 ;
6755 PyObject *swig_obj[1] ;
6756
6757 if (!args) SWIG_fail;
6758 swig_obj[0] = args;
6759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6760 if (!SWIG_IsOK(res1)) {
6761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6762 }
6763 arg1 = reinterpret_cast< wxRect * >(argp1);
6764 {
6765 PyThreadState* __tstate = wxPyBeginAllowThreads();
6766 result = ((wxRect const *)arg1)->GetBottomRight();
6767 wxPyEndAllowThreads(__tstate);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6778 PyObject *resultobj = 0;
6779 wxRect *arg1 = (wxRect *) 0 ;
6780 wxPoint *arg2 = 0 ;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 wxPoint temp2 ;
6784 PyObject * obj0 = 0 ;
6785 PyObject * obj1 = 0 ;
6786 char * kwnames[] = {
6787 (char *) "self",(char *) "p", NULL
6788 };
6789
6790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6792 if (!SWIG_IsOK(res1)) {
6793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6794 }
6795 arg1 = reinterpret_cast< wxRect * >(argp1);
6796 {
6797 arg2 = &temp2;
6798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6799 }
6800 {
6801 PyThreadState* __tstate = wxPyBeginAllowThreads();
6802 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 resultobj = SWIG_Py_Void();
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6814 PyObject *resultobj = 0;
6815 wxRect *arg1 = (wxRect *) 0 ;
6816 int result;
6817 void *argp1 = 0 ;
6818 int res1 = 0 ;
6819 PyObject *swig_obj[1] ;
6820
6821 if (!args) SWIG_fail;
6822 swig_obj[0] = args;
6823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6824 if (!SWIG_IsOK(res1)) {
6825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6826 }
6827 arg1 = reinterpret_cast< wxRect * >(argp1);
6828 {
6829 PyThreadState* __tstate = wxPyBeginAllowThreads();
6830 result = (int)((wxRect const *)arg1)->GetLeft();
6831 wxPyEndAllowThreads(__tstate);
6832 if (PyErr_Occurred()) SWIG_fail;
6833 }
6834 resultobj = SWIG_From_int(static_cast< int >(result));
6835 return resultobj;
6836 fail:
6837 return NULL;
6838 }
6839
6840
6841 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6842 PyObject *resultobj = 0;
6843 wxRect *arg1 = (wxRect *) 0 ;
6844 int result;
6845 void *argp1 = 0 ;
6846 int res1 = 0 ;
6847 PyObject *swig_obj[1] ;
6848
6849 if (!args) SWIG_fail;
6850 swig_obj[0] = args;
6851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6852 if (!SWIG_IsOK(res1)) {
6853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6854 }
6855 arg1 = reinterpret_cast< wxRect * >(argp1);
6856 {
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 result = (int)((wxRect const *)arg1)->GetTop();
6859 wxPyEndAllowThreads(__tstate);
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_From_int(static_cast< int >(result));
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6870 PyObject *resultobj = 0;
6871 wxRect *arg1 = (wxRect *) 0 ;
6872 int result;
6873 void *argp1 = 0 ;
6874 int res1 = 0 ;
6875 PyObject *swig_obj[1] ;
6876
6877 if (!args) SWIG_fail;
6878 swig_obj[0] = args;
6879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6880 if (!SWIG_IsOK(res1)) {
6881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6882 }
6883 arg1 = reinterpret_cast< wxRect * >(argp1);
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 result = (int)((wxRect const *)arg1)->GetBottom();
6887 wxPyEndAllowThreads(__tstate);
6888 if (PyErr_Occurred()) SWIG_fail;
6889 }
6890 resultobj = SWIG_From_int(static_cast< int >(result));
6891 return resultobj;
6892 fail:
6893 return NULL;
6894 }
6895
6896
6897 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6898 PyObject *resultobj = 0;
6899 wxRect *arg1 = (wxRect *) 0 ;
6900 int result;
6901 void *argp1 = 0 ;
6902 int res1 = 0 ;
6903 PyObject *swig_obj[1] ;
6904
6905 if (!args) SWIG_fail;
6906 swig_obj[0] = args;
6907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6908 if (!SWIG_IsOK(res1)) {
6909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6910 }
6911 arg1 = reinterpret_cast< wxRect * >(argp1);
6912 {
6913 PyThreadState* __tstate = wxPyBeginAllowThreads();
6914 result = (int)((wxRect const *)arg1)->GetRight();
6915 wxPyEndAllowThreads(__tstate);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 resultobj = SWIG_From_int(static_cast< int >(result));
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj = 0;
6927 wxRect *arg1 = (wxRect *) 0 ;
6928 int arg2 ;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 int val2 ;
6932 int ecode2 = 0 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 char * kwnames[] = {
6936 (char *) "self",(char *) "left", NULL
6937 };
6938
6939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6941 if (!SWIG_IsOK(res1)) {
6942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6943 }
6944 arg1 = reinterpret_cast< wxRect * >(argp1);
6945 ecode2 = SWIG_AsVal_int(obj1, &val2);
6946 if (!SWIG_IsOK(ecode2)) {
6947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6948 }
6949 arg2 = static_cast< int >(val2);
6950 {
6951 PyThreadState* __tstate = wxPyBeginAllowThreads();
6952 (arg1)->SetLeft(arg2);
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_Py_Void();
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj = 0;
6965 wxRect *arg1 = (wxRect *) 0 ;
6966 int arg2 ;
6967 void *argp1 = 0 ;
6968 int res1 = 0 ;
6969 int val2 ;
6970 int ecode2 = 0 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char * kwnames[] = {
6974 (char *) "self",(char *) "right", NULL
6975 };
6976
6977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6979 if (!SWIG_IsOK(res1)) {
6980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6981 }
6982 arg1 = reinterpret_cast< wxRect * >(argp1);
6983 ecode2 = SWIG_AsVal_int(obj1, &val2);
6984 if (!SWIG_IsOK(ecode2)) {
6985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6986 }
6987 arg2 = static_cast< int >(val2);
6988 {
6989 PyThreadState* __tstate = wxPyBeginAllowThreads();
6990 (arg1)->SetRight(arg2);
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_Py_Void();
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj = 0;
7003 wxRect *arg1 = (wxRect *) 0 ;
7004 int arg2 ;
7005 void *argp1 = 0 ;
7006 int res1 = 0 ;
7007 int val2 ;
7008 int ecode2 = 0 ;
7009 PyObject * obj0 = 0 ;
7010 PyObject * obj1 = 0 ;
7011 char * kwnames[] = {
7012 (char *) "self",(char *) "top", NULL
7013 };
7014
7015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7017 if (!SWIG_IsOK(res1)) {
7018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7019 }
7020 arg1 = reinterpret_cast< wxRect * >(argp1);
7021 ecode2 = SWIG_AsVal_int(obj1, &val2);
7022 if (!SWIG_IsOK(ecode2)) {
7023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7024 }
7025 arg2 = static_cast< int >(val2);
7026 {
7027 PyThreadState* __tstate = wxPyBeginAllowThreads();
7028 (arg1)->SetTop(arg2);
7029 wxPyEndAllowThreads(__tstate);
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 resultobj = SWIG_Py_Void();
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7040 PyObject *resultobj = 0;
7041 wxRect *arg1 = (wxRect *) 0 ;
7042 int arg2 ;
7043 void *argp1 = 0 ;
7044 int res1 = 0 ;
7045 int val2 ;
7046 int ecode2 = 0 ;
7047 PyObject * obj0 = 0 ;
7048 PyObject * obj1 = 0 ;
7049 char * kwnames[] = {
7050 (char *) "self",(char *) "bottom", NULL
7051 };
7052
7053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7055 if (!SWIG_IsOK(res1)) {
7056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7057 }
7058 arg1 = reinterpret_cast< wxRect * >(argp1);
7059 ecode2 = SWIG_AsVal_int(obj1, &val2);
7060 if (!SWIG_IsOK(ecode2)) {
7061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7062 }
7063 arg2 = static_cast< int >(val2);
7064 {
7065 PyThreadState* __tstate = wxPyBeginAllowThreads();
7066 (arg1)->SetBottom(arg2);
7067 wxPyEndAllowThreads(__tstate);
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 resultobj = SWIG_Py_Void();
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7078 PyObject *resultobj = 0;
7079 wxRect *arg1 = (wxRect *) 0 ;
7080 int arg2 ;
7081 int arg3 ;
7082 wxRect *result = 0 ;
7083 void *argp1 = 0 ;
7084 int res1 = 0 ;
7085 int val2 ;
7086 int ecode2 = 0 ;
7087 int val3 ;
7088 int ecode3 = 0 ;
7089 PyObject * obj0 = 0 ;
7090 PyObject * obj1 = 0 ;
7091 PyObject * obj2 = 0 ;
7092 char * kwnames[] = {
7093 (char *) "self",(char *) "dx",(char *) "dy", NULL
7094 };
7095
7096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7098 if (!SWIG_IsOK(res1)) {
7099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7100 }
7101 arg1 = reinterpret_cast< wxRect * >(argp1);
7102 ecode2 = SWIG_AsVal_int(obj1, &val2);
7103 if (!SWIG_IsOK(ecode2)) {
7104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7105 }
7106 arg2 = static_cast< int >(val2);
7107 ecode3 = SWIG_AsVal_int(obj2, &val3);
7108 if (!SWIG_IsOK(ecode3)) {
7109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7110 }
7111 arg3 = static_cast< int >(val3);
7112 {
7113 PyThreadState* __tstate = wxPyBeginAllowThreads();
7114 {
7115 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7116 result = (wxRect *) &_result_ref;
7117 }
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 int arg2 ;
7132 int arg3 ;
7133 wxRect *result = 0 ;
7134 void *argp1 = 0 ;
7135 int res1 = 0 ;
7136 int val2 ;
7137 int ecode2 = 0 ;
7138 int val3 ;
7139 int ecode3 = 0 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 PyObject * obj2 = 0 ;
7143 char * kwnames[] = {
7144 (char *) "self",(char *) "dx",(char *) "dy", NULL
7145 };
7146
7147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7149 if (!SWIG_IsOK(res1)) {
7150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7151 }
7152 arg1 = reinterpret_cast< wxRect * >(argp1);
7153 ecode2 = SWIG_AsVal_int(obj1, &val2);
7154 if (!SWIG_IsOK(ecode2)) {
7155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7156 }
7157 arg2 = static_cast< int >(val2);
7158 ecode3 = SWIG_AsVal_int(obj2, &val3);
7159 if (!SWIG_IsOK(ecode3)) {
7160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7161 }
7162 arg3 = static_cast< int >(val3);
7163 {
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 {
7166 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7167 result = (wxRect *) &_result_ref;
7168 }
7169 wxPyEndAllowThreads(__tstate);
7170 if (PyErr_Occurred()) SWIG_fail;
7171 }
7172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj = 0;
7181 wxRect *arg1 = (wxRect *) 0 ;
7182 int arg2 ;
7183 int arg3 ;
7184 void *argp1 = 0 ;
7185 int res1 = 0 ;
7186 int val2 ;
7187 int ecode2 = 0 ;
7188 int val3 ;
7189 int ecode3 = 0 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 PyObject * obj2 = 0 ;
7193 char * kwnames[] = {
7194 (char *) "self",(char *) "dx",(char *) "dy", NULL
7195 };
7196
7197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7199 if (!SWIG_IsOK(res1)) {
7200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7201 }
7202 arg1 = reinterpret_cast< wxRect * >(argp1);
7203 ecode2 = SWIG_AsVal_int(obj1, &val2);
7204 if (!SWIG_IsOK(ecode2)) {
7205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7206 }
7207 arg2 = static_cast< int >(val2);
7208 ecode3 = SWIG_AsVal_int(obj2, &val3);
7209 if (!SWIG_IsOK(ecode3)) {
7210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7211 }
7212 arg3 = static_cast< int >(val3);
7213 {
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 (arg1)->Offset(arg2,arg3);
7216 wxPyEndAllowThreads(__tstate);
7217 if (PyErr_Occurred()) SWIG_fail;
7218 }
7219 resultobj = SWIG_Py_Void();
7220 return resultobj;
7221 fail:
7222 return NULL;
7223 }
7224
7225
7226 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7227 PyObject *resultobj = 0;
7228 wxRect *arg1 = (wxRect *) 0 ;
7229 wxPoint *arg2 = 0 ;
7230 void *argp1 = 0 ;
7231 int res1 = 0 ;
7232 wxPoint temp2 ;
7233 PyObject * obj0 = 0 ;
7234 PyObject * obj1 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "self",(char *) "pt", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7243 }
7244 arg1 = reinterpret_cast< wxRect * >(argp1);
7245 {
7246 arg2 = &temp2;
7247 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7248 }
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 (arg1)->Offset((wxPoint const &)*arg2);
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = SWIG_Py_Void();
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj = 0;
7264 wxRect *arg1 = (wxRect *) 0 ;
7265 wxRect *arg2 = 0 ;
7266 wxRect result;
7267 void *argp1 = 0 ;
7268 int res1 = 0 ;
7269 wxRect temp2 ;
7270 PyObject * obj0 = 0 ;
7271 PyObject * obj1 = 0 ;
7272 char * kwnames[] = {
7273 (char *) "self",(char *) "rect", NULL
7274 };
7275
7276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7280 }
7281 arg1 = reinterpret_cast< wxRect * >(argp1);
7282 {
7283 arg2 = &temp2;
7284 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7285 }
7286 {
7287 PyThreadState* __tstate = wxPyBeginAllowThreads();
7288 result = (arg1)->Intersect((wxRect const &)*arg2);
7289 wxPyEndAllowThreads(__tstate);
7290 if (PyErr_Occurred()) SWIG_fail;
7291 }
7292 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7293 return resultobj;
7294 fail:
7295 return NULL;
7296 }
7297
7298
7299 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj = 0;
7301 wxRect *arg1 = (wxRect *) 0 ;
7302 wxRect *arg2 = 0 ;
7303 wxRect result;
7304 void *argp1 = 0 ;
7305 int res1 = 0 ;
7306 wxRect temp2 ;
7307 PyObject * obj0 = 0 ;
7308 PyObject * obj1 = 0 ;
7309 char * kwnames[] = {
7310 (char *) "self",(char *) "rect", NULL
7311 };
7312
7313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7315 if (!SWIG_IsOK(res1)) {
7316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7317 }
7318 arg1 = reinterpret_cast< wxRect * >(argp1);
7319 {
7320 arg2 = &temp2;
7321 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7322 }
7323 {
7324 PyThreadState* __tstate = wxPyBeginAllowThreads();
7325 result = (arg1)->Union((wxRect const &)*arg2);
7326 wxPyEndAllowThreads(__tstate);
7327 if (PyErr_Occurred()) SWIG_fail;
7328 }
7329 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7337 PyObject *resultobj = 0;
7338 wxRect *arg1 = (wxRect *) 0 ;
7339 wxRect *arg2 = 0 ;
7340 wxRect result;
7341 void *argp1 = 0 ;
7342 int res1 = 0 ;
7343 wxRect temp2 ;
7344 PyObject * obj0 = 0 ;
7345 PyObject * obj1 = 0 ;
7346 char * kwnames[] = {
7347 (char *) "self",(char *) "rect", NULL
7348 };
7349
7350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7352 if (!SWIG_IsOK(res1)) {
7353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7354 }
7355 arg1 = reinterpret_cast< wxRect * >(argp1);
7356 {
7357 arg2 = &temp2;
7358 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7359 }
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7363 wxPyEndAllowThreads(__tstate);
7364 if (PyErr_Occurred()) SWIG_fail;
7365 }
7366 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7374 PyObject *resultobj = 0;
7375 wxRect *arg1 = (wxRect *) 0 ;
7376 wxRect *arg2 = 0 ;
7377 wxRect *result = 0 ;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 wxRect temp2 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "rect", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 {
7394 arg2 = &temp2;
7395 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7396 }
7397 {
7398 PyThreadState* __tstate = wxPyBeginAllowThreads();
7399 {
7400 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7401 result = (wxRect *) &_result_ref;
7402 }
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj = 0;
7415 wxRect *arg1 = (wxRect *) 0 ;
7416 PyObject *arg2 = (PyObject *) 0 ;
7417 bool result;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 PyObject * obj0 = 0 ;
7421 PyObject * obj1 = 0 ;
7422 char * kwnames[] = {
7423 (char *) "self",(char *) "other", NULL
7424 };
7425
7426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7428 if (!SWIG_IsOK(res1)) {
7429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7430 }
7431 arg1 = reinterpret_cast< wxRect * >(argp1);
7432 arg2 = obj1;
7433 {
7434 result = (bool)wxRect___eq__(arg1,arg2);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 {
7438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7439 }
7440 return resultobj;
7441 fail:
7442 return NULL;
7443 }
7444
7445
7446 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7447 PyObject *resultobj = 0;
7448 wxRect *arg1 = (wxRect *) 0 ;
7449 PyObject *arg2 = (PyObject *) 0 ;
7450 bool result;
7451 void *argp1 = 0 ;
7452 int res1 = 0 ;
7453 PyObject * obj0 = 0 ;
7454 PyObject * obj1 = 0 ;
7455 char * kwnames[] = {
7456 (char *) "self",(char *) "other", NULL
7457 };
7458
7459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7461 if (!SWIG_IsOK(res1)) {
7462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7463 }
7464 arg1 = reinterpret_cast< wxRect * >(argp1);
7465 arg2 = obj1;
7466 {
7467 result = (bool)wxRect___ne__(arg1,arg2);
7468 if (PyErr_Occurred()) SWIG_fail;
7469 }
7470 {
7471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7472 }
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj = 0;
7481 wxRect *arg1 = (wxRect *) 0 ;
7482 int arg2 ;
7483 int arg3 ;
7484 bool result;
7485 void *argp1 = 0 ;
7486 int res1 = 0 ;
7487 int val2 ;
7488 int ecode2 = 0 ;
7489 int val3 ;
7490 int ecode3 = 0 ;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 PyObject * obj2 = 0 ;
7494 char * kwnames[] = {
7495 (char *) "self",(char *) "x",(char *) "y", NULL
7496 };
7497
7498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7500 if (!SWIG_IsOK(res1)) {
7501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7502 }
7503 arg1 = reinterpret_cast< wxRect * >(argp1);
7504 ecode2 = SWIG_AsVal_int(obj1, &val2);
7505 if (!SWIG_IsOK(ecode2)) {
7506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7507 }
7508 arg2 = static_cast< int >(val2);
7509 ecode3 = SWIG_AsVal_int(obj2, &val3);
7510 if (!SWIG_IsOK(ecode3)) {
7511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7512 }
7513 arg3 = static_cast< int >(val3);
7514 {
7515 PyThreadState* __tstate = wxPyBeginAllowThreads();
7516 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 {
7521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7522 }
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj = 0;
7531 wxRect *arg1 = (wxRect *) 0 ;
7532 wxPoint *arg2 = 0 ;
7533 bool result;
7534 void *argp1 = 0 ;
7535 int res1 = 0 ;
7536 wxPoint temp2 ;
7537 PyObject * obj0 = 0 ;
7538 PyObject * obj1 = 0 ;
7539 char * kwnames[] = {
7540 (char *) "self",(char *) "pt", NULL
7541 };
7542
7543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7545 if (!SWIG_IsOK(res1)) {
7546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7547 }
7548 arg1 = reinterpret_cast< wxRect * >(argp1);
7549 {
7550 arg2 = &temp2;
7551 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7552 }
7553 {
7554 PyThreadState* __tstate = wxPyBeginAllowThreads();
7555 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 {
7560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7561 }
7562 return resultobj;
7563 fail:
7564 return NULL;
7565 }
7566
7567
7568 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7569 PyObject *resultobj = 0;
7570 wxRect *arg1 = (wxRect *) 0 ;
7571 wxRect *arg2 = 0 ;
7572 bool result;
7573 void *argp1 = 0 ;
7574 int res1 = 0 ;
7575 wxRect temp2 ;
7576 PyObject * obj0 = 0 ;
7577 PyObject * obj1 = 0 ;
7578 char * kwnames[] = {
7579 (char *) "self",(char *) "rect", NULL
7580 };
7581
7582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7584 if (!SWIG_IsOK(res1)) {
7585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7586 }
7587 arg1 = reinterpret_cast< wxRect * >(argp1);
7588 {
7589 arg2 = &temp2;
7590 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7591 }
7592 {
7593 PyThreadState* __tstate = wxPyBeginAllowThreads();
7594 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 {
7599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7600 }
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7608 PyObject *resultobj = 0;
7609 wxRect *arg1 = (wxRect *) 0 ;
7610 wxRect *arg2 = 0 ;
7611 bool result;
7612 void *argp1 = 0 ;
7613 int res1 = 0 ;
7614 wxRect temp2 ;
7615 PyObject * obj0 = 0 ;
7616 PyObject * obj1 = 0 ;
7617 char * kwnames[] = {
7618 (char *) "self",(char *) "rect", NULL
7619 };
7620
7621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7623 if (!SWIG_IsOK(res1)) {
7624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7625 }
7626 arg1 = reinterpret_cast< wxRect * >(argp1);
7627 {
7628 arg2 = &temp2;
7629 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7630 }
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 {
7638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7639 }
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj = 0;
7648 wxRect *arg1 = (wxRect *) 0 ;
7649 wxRect *arg2 = 0 ;
7650 int arg3 = (int) wxBOTH ;
7651 wxRect result;
7652 void *argp1 = 0 ;
7653 int res1 = 0 ;
7654 wxRect temp2 ;
7655 int val3 ;
7656 int ecode3 = 0 ;
7657 PyObject * obj0 = 0 ;
7658 PyObject * obj1 = 0 ;
7659 PyObject * obj2 = 0 ;
7660 char * kwnames[] = {
7661 (char *) "self",(char *) "r",(char *) "dir", NULL
7662 };
7663
7664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7666 if (!SWIG_IsOK(res1)) {
7667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7668 }
7669 arg1 = reinterpret_cast< wxRect * >(argp1);
7670 {
7671 arg2 = &temp2;
7672 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7673 }
7674 if (obj2) {
7675 ecode3 = SWIG_AsVal_int(obj2, &val3);
7676 if (!SWIG_IsOK(ecode3)) {
7677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7678 }
7679 arg3 = static_cast< int >(val3);
7680 }
7681 {
7682 PyThreadState* __tstate = wxPyBeginAllowThreads();
7683 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7684 wxPyEndAllowThreads(__tstate);
7685 if (PyErr_Occurred()) SWIG_fail;
7686 }
7687 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7688 return resultobj;
7689 fail:
7690 return NULL;
7691 }
7692
7693
7694 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7695 PyObject *resultobj = 0;
7696 wxRect *arg1 = (wxRect *) 0 ;
7697 int arg2 ;
7698 void *argp1 = 0 ;
7699 int res1 = 0 ;
7700 int val2 ;
7701 int ecode2 = 0 ;
7702 PyObject *swig_obj[2] ;
7703
7704 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7706 if (!SWIG_IsOK(res1)) {
7707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7708 }
7709 arg1 = reinterpret_cast< wxRect * >(argp1);
7710 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7711 if (!SWIG_IsOK(ecode2)) {
7712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7713 }
7714 arg2 = static_cast< int >(val2);
7715 if (arg1) (arg1)->x = arg2;
7716
7717 resultobj = SWIG_Py_Void();
7718 return resultobj;
7719 fail:
7720 return NULL;
7721 }
7722
7723
7724 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7725 PyObject *resultobj = 0;
7726 wxRect *arg1 = (wxRect *) 0 ;
7727 int result;
7728 void *argp1 = 0 ;
7729 int res1 = 0 ;
7730 PyObject *swig_obj[1] ;
7731
7732 if (!args) SWIG_fail;
7733 swig_obj[0] = args;
7734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7735 if (!SWIG_IsOK(res1)) {
7736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7737 }
7738 arg1 = reinterpret_cast< wxRect * >(argp1);
7739 result = (int) ((arg1)->x);
7740 resultobj = SWIG_From_int(static_cast< int >(result));
7741 return resultobj;
7742 fail:
7743 return NULL;
7744 }
7745
7746
7747 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7748 PyObject *resultobj = 0;
7749 wxRect *arg1 = (wxRect *) 0 ;
7750 int arg2 ;
7751 void *argp1 = 0 ;
7752 int res1 = 0 ;
7753 int val2 ;
7754 int ecode2 = 0 ;
7755 PyObject *swig_obj[2] ;
7756
7757 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7761 }
7762 arg1 = reinterpret_cast< wxRect * >(argp1);
7763 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7764 if (!SWIG_IsOK(ecode2)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7766 }
7767 arg2 = static_cast< int >(val2);
7768 if (arg1) (arg1)->y = arg2;
7769
7770 resultobj = SWIG_Py_Void();
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7778 PyObject *resultobj = 0;
7779 wxRect *arg1 = (wxRect *) 0 ;
7780 int result;
7781 void *argp1 = 0 ;
7782 int res1 = 0 ;
7783 PyObject *swig_obj[1] ;
7784
7785 if (!args) SWIG_fail;
7786 swig_obj[0] = args;
7787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7788 if (!SWIG_IsOK(res1)) {
7789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7790 }
7791 arg1 = reinterpret_cast< wxRect * >(argp1);
7792 result = (int) ((arg1)->y);
7793 resultobj = SWIG_From_int(static_cast< int >(result));
7794 return resultobj;
7795 fail:
7796 return NULL;
7797 }
7798
7799
7800 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7801 PyObject *resultobj = 0;
7802 wxRect *arg1 = (wxRect *) 0 ;
7803 int arg2 ;
7804 void *argp1 = 0 ;
7805 int res1 = 0 ;
7806 int val2 ;
7807 int ecode2 = 0 ;
7808 PyObject *swig_obj[2] ;
7809
7810 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7812 if (!SWIG_IsOK(res1)) {
7813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7814 }
7815 arg1 = reinterpret_cast< wxRect * >(argp1);
7816 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7817 if (!SWIG_IsOK(ecode2)) {
7818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7819 }
7820 arg2 = static_cast< int >(val2);
7821 if (arg1) (arg1)->width = arg2;
7822
7823 resultobj = SWIG_Py_Void();
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7831 PyObject *resultobj = 0;
7832 wxRect *arg1 = (wxRect *) 0 ;
7833 int result;
7834 void *argp1 = 0 ;
7835 int res1 = 0 ;
7836 PyObject *swig_obj[1] ;
7837
7838 if (!args) SWIG_fail;
7839 swig_obj[0] = args;
7840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7841 if (!SWIG_IsOK(res1)) {
7842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7843 }
7844 arg1 = reinterpret_cast< wxRect * >(argp1);
7845 result = (int) ((arg1)->width);
7846 resultobj = SWIG_From_int(static_cast< int >(result));
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
7853 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7854 PyObject *resultobj = 0;
7855 wxRect *arg1 = (wxRect *) 0 ;
7856 int arg2 ;
7857 void *argp1 = 0 ;
7858 int res1 = 0 ;
7859 int val2 ;
7860 int ecode2 = 0 ;
7861 PyObject *swig_obj[2] ;
7862
7863 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7865 if (!SWIG_IsOK(res1)) {
7866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7867 }
7868 arg1 = reinterpret_cast< wxRect * >(argp1);
7869 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7870 if (!SWIG_IsOK(ecode2)) {
7871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7872 }
7873 arg2 = static_cast< int >(val2);
7874 if (arg1) (arg1)->height = arg2;
7875
7876 resultobj = SWIG_Py_Void();
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7884 PyObject *resultobj = 0;
7885 wxRect *arg1 = (wxRect *) 0 ;
7886 int result;
7887 void *argp1 = 0 ;
7888 int res1 = 0 ;
7889 PyObject *swig_obj[1] ;
7890
7891 if (!args) SWIG_fail;
7892 swig_obj[0] = args;
7893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7894 if (!SWIG_IsOK(res1)) {
7895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7896 }
7897 arg1 = reinterpret_cast< wxRect * >(argp1);
7898 result = (int) ((arg1)->height);
7899 resultobj = SWIG_From_int(static_cast< int >(result));
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7907 PyObject *resultobj = 0;
7908 wxRect *arg1 = (wxRect *) 0 ;
7909 int arg2 = (int) 0 ;
7910 int arg3 = (int) 0 ;
7911 int arg4 = (int) 0 ;
7912 int arg5 = (int) 0 ;
7913 void *argp1 = 0 ;
7914 int res1 = 0 ;
7915 int val2 ;
7916 int ecode2 = 0 ;
7917 int val3 ;
7918 int ecode3 = 0 ;
7919 int val4 ;
7920 int ecode4 = 0 ;
7921 int val5 ;
7922 int ecode5 = 0 ;
7923 PyObject * obj0 = 0 ;
7924 PyObject * obj1 = 0 ;
7925 PyObject * obj2 = 0 ;
7926 PyObject * obj3 = 0 ;
7927 PyObject * obj4 = 0 ;
7928 char * kwnames[] = {
7929 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7930 };
7931
7932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7934 if (!SWIG_IsOK(res1)) {
7935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7936 }
7937 arg1 = reinterpret_cast< wxRect * >(argp1);
7938 if (obj1) {
7939 ecode2 = SWIG_AsVal_int(obj1, &val2);
7940 if (!SWIG_IsOK(ecode2)) {
7941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7942 }
7943 arg2 = static_cast< int >(val2);
7944 }
7945 if (obj2) {
7946 ecode3 = SWIG_AsVal_int(obj2, &val3);
7947 if (!SWIG_IsOK(ecode3)) {
7948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7949 }
7950 arg3 = static_cast< int >(val3);
7951 }
7952 if (obj3) {
7953 ecode4 = SWIG_AsVal_int(obj3, &val4);
7954 if (!SWIG_IsOK(ecode4)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7956 }
7957 arg4 = static_cast< int >(val4);
7958 }
7959 if (obj4) {
7960 ecode5 = SWIG_AsVal_int(obj4, &val5);
7961 if (!SWIG_IsOK(ecode5)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7963 }
7964 arg5 = static_cast< int >(val5);
7965 }
7966 {
7967 PyThreadState* __tstate = wxPyBeginAllowThreads();
7968 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7969 wxPyEndAllowThreads(__tstate);
7970 if (PyErr_Occurred()) SWIG_fail;
7971 }
7972 resultobj = SWIG_Py_Void();
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7980 PyObject *resultobj = 0;
7981 wxRect *arg1 = (wxRect *) 0 ;
7982 PyObject *result = 0 ;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 PyObject *swig_obj[1] ;
7986
7987 if (!args) SWIG_fail;
7988 swig_obj[0] = args;
7989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7992 }
7993 arg1 = reinterpret_cast< wxRect * >(argp1);
7994 {
7995 PyThreadState* __tstate = wxPyBeginAllowThreads();
7996 result = (PyObject *)wxRect_Get(arg1);
7997 wxPyEndAllowThreads(__tstate);
7998 if (PyErr_Occurred()) SWIG_fail;
7999 }
8000 resultobj = result;
8001 return resultobj;
8002 fail:
8003 return NULL;
8004 }
8005
8006
8007 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8008 PyObject *obj;
8009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8010 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8011 return SWIG_Py_Void();
8012 }
8013
8014 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8015 return SWIG_Python_InitShadowInstance(args);
8016 }
8017
8018 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8019 PyObject *resultobj = 0;
8020 wxRect *arg1 = (wxRect *) 0 ;
8021 wxRect *arg2 = (wxRect *) 0 ;
8022 PyObject *result = 0 ;
8023 void *argp1 = 0 ;
8024 int res1 = 0 ;
8025 void *argp2 = 0 ;
8026 int res2 = 0 ;
8027 PyObject * obj0 = 0 ;
8028 PyObject * obj1 = 0 ;
8029 char * kwnames[] = {
8030 (char *) "r1",(char *) "r2", NULL
8031 };
8032
8033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8037 }
8038 arg1 = reinterpret_cast< wxRect * >(argp1);
8039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8040 if (!SWIG_IsOK(res2)) {
8041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8042 }
8043 arg2 = reinterpret_cast< wxRect * >(argp2);
8044 {
8045 if (!wxPyCheckForApp()) SWIG_fail;
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 result = (PyObject *)wxIntersectRect(arg1,arg2);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = result;
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8059 PyObject *resultobj = 0;
8060 double arg1 = (double) 0.0 ;
8061 double arg2 = (double) 0.0 ;
8062 wxPoint2D *result = 0 ;
8063 double val1 ;
8064 int ecode1 = 0 ;
8065 double val2 ;
8066 int ecode2 = 0 ;
8067 PyObject * obj0 = 0 ;
8068 PyObject * obj1 = 0 ;
8069 char * kwnames[] = {
8070 (char *) "x",(char *) "y", NULL
8071 };
8072
8073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8074 if (obj0) {
8075 ecode1 = SWIG_AsVal_double(obj0, &val1);
8076 if (!SWIG_IsOK(ecode1)) {
8077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8078 }
8079 arg1 = static_cast< double >(val1);
8080 }
8081 if (obj1) {
8082 ecode2 = SWIG_AsVal_double(obj1, &val2);
8083 if (!SWIG_IsOK(ecode2)) {
8084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8085 }
8086 arg2 = static_cast< double >(val2);
8087 }
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8102 PyObject *resultobj = 0;
8103 wxPoint2D *arg1 = 0 ;
8104 wxPoint2D *result = 0 ;
8105 wxPoint2D temp1 ;
8106 PyObject * obj0 = 0 ;
8107 char * kwnames[] = {
8108 (char *) "pt", NULL
8109 };
8110
8111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8112 {
8113 arg1 = &temp1;
8114 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8115 }
8116 {
8117 PyThreadState* __tstate = wxPyBeginAllowThreads();
8118 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8119 wxPyEndAllowThreads(__tstate);
8120 if (PyErr_Occurred()) SWIG_fail;
8121 }
8122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj = 0;
8131 wxPoint *arg1 = 0 ;
8132 wxPoint2D *result = 0 ;
8133 wxPoint temp1 ;
8134 PyObject * obj0 = 0 ;
8135 char * kwnames[] = {
8136 (char *) "pt", NULL
8137 };
8138
8139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8140 {
8141 arg1 = &temp1;
8142 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8143 }
8144 {
8145 PyThreadState* __tstate = wxPyBeginAllowThreads();
8146 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8151 return resultobj;
8152 fail:
8153 return NULL;
8154 }
8155
8156
8157 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8158 PyObject *resultobj = 0;
8159 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8160 int *arg2 = (int *) 0 ;
8161 int *arg3 = (int *) 0 ;
8162 void *argp1 = 0 ;
8163 int res1 = 0 ;
8164 int temp2 ;
8165 int res2 = SWIG_TMPOBJ ;
8166 int temp3 ;
8167 int res3 = SWIG_TMPOBJ ;
8168 PyObject *swig_obj[1] ;
8169
8170 arg2 = &temp2;
8171 arg3 = &temp3;
8172 if (!args) SWIG_fail;
8173 swig_obj[0] = args;
8174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8175 if (!SWIG_IsOK(res1)) {
8176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8177 }
8178 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8179 {
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 resultobj = SWIG_Py_Void();
8186 if (SWIG_IsTmpObj(res2)) {
8187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8188 } else {
8189 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8191 }
8192 if (SWIG_IsTmpObj(res3)) {
8193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8194 } else {
8195 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8197 }
8198 return resultobj;
8199 fail:
8200 return NULL;
8201 }
8202
8203
8204 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8205 PyObject *resultobj = 0;
8206 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8207 int *arg2 = (int *) 0 ;
8208 int *arg3 = (int *) 0 ;
8209 void *argp1 = 0 ;
8210 int res1 = 0 ;
8211 int temp2 ;
8212 int res2 = SWIG_TMPOBJ ;
8213 int temp3 ;
8214 int res3 = SWIG_TMPOBJ ;
8215 PyObject *swig_obj[1] ;
8216
8217 arg2 = &temp2;
8218 arg3 = &temp3;
8219 if (!args) SWIG_fail;
8220 swig_obj[0] = args;
8221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8222 if (!SWIG_IsOK(res1)) {
8223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8224 }
8225 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_Py_Void();
8233 if (SWIG_IsTmpObj(res2)) {
8234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8235 } else {
8236 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8238 }
8239 if (SWIG_IsTmpObj(res3)) {
8240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8241 } else {
8242 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8244 }
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8252 PyObject *resultobj = 0;
8253 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8254 double result;
8255 void *argp1 = 0 ;
8256 int res1 = 0 ;
8257 PyObject *swig_obj[1] ;
8258
8259 if (!args) SWIG_fail;
8260 swig_obj[0] = args;
8261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8262 if (!SWIG_IsOK(res1)) {
8263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8264 }
8265 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 resultobj = SWIG_From_double(static_cast< double >(result));
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8280 PyObject *resultobj = 0;
8281 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8282 double result;
8283 void *argp1 = 0 ;
8284 int res1 = 0 ;
8285 PyObject *swig_obj[1] ;
8286
8287 if (!args) SWIG_fail;
8288 swig_obj[0] = args;
8289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8290 if (!SWIG_IsOK(res1)) {
8291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8292 }
8293 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8294 {
8295 PyThreadState* __tstate = wxPyBeginAllowThreads();
8296 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8297 wxPyEndAllowThreads(__tstate);
8298 if (PyErr_Occurred()) SWIG_fail;
8299 }
8300 resultobj = SWIG_From_double(static_cast< double >(result));
8301 return resultobj;
8302 fail:
8303 return NULL;
8304 }
8305
8306
8307 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8308 PyObject *resultobj = 0;
8309 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8310 double arg2 ;
8311 void *argp1 = 0 ;
8312 int res1 = 0 ;
8313 double val2 ;
8314 int ecode2 = 0 ;
8315 PyObject * obj0 = 0 ;
8316 PyObject * obj1 = 0 ;
8317 char * kwnames[] = {
8318 (char *) "self",(char *) "length", NULL
8319 };
8320
8321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8323 if (!SWIG_IsOK(res1)) {
8324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8325 }
8326 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8327 ecode2 = SWIG_AsVal_double(obj1, &val2);
8328 if (!SWIG_IsOK(ecode2)) {
8329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8330 }
8331 arg2 = static_cast< double >(val2);
8332 {
8333 PyThreadState* __tstate = wxPyBeginAllowThreads();
8334 (arg1)->SetVectorLength(arg2);
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 resultobj = SWIG_Py_Void();
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj = 0;
8347 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8348 double arg2 ;
8349 void *argp1 = 0 ;
8350 int res1 = 0 ;
8351 double val2 ;
8352 int ecode2 = 0 ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 char * kwnames[] = {
8356 (char *) "self",(char *) "degrees", NULL
8357 };
8358
8359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8361 if (!SWIG_IsOK(res1)) {
8362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8363 }
8364 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8365 ecode2 = SWIG_AsVal_double(obj1, &val2);
8366 if (!SWIG_IsOK(ecode2)) {
8367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8368 }
8369 arg2 = static_cast< double >(val2);
8370 {
8371 PyThreadState* __tstate = wxPyBeginAllowThreads();
8372 (arg1)->SetVectorAngle(arg2);
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 resultobj = SWIG_Py_Void();
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8384 PyObject *resultobj = 0;
8385 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8386 wxPoint2D *arg2 = 0 ;
8387 double result;
8388 void *argp1 = 0 ;
8389 int res1 = 0 ;
8390 wxPoint2D temp2 ;
8391 PyObject * obj0 = 0 ;
8392 PyObject * obj1 = 0 ;
8393 char * kwnames[] = {
8394 (char *) "self",(char *) "pt", NULL
8395 };
8396
8397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8399 if (!SWIG_IsOK(res1)) {
8400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8401 }
8402 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8403 {
8404 arg2 = &temp2;
8405 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8406 }
8407 {
8408 PyThreadState* __tstate = wxPyBeginAllowThreads();
8409 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8410 wxPyEndAllowThreads(__tstate);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_From_double(static_cast< double >(result));
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8421 PyObject *resultobj = 0;
8422 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8423 wxPoint2D *arg2 = 0 ;
8424 double result;
8425 void *argp1 = 0 ;
8426 int res1 = 0 ;
8427 wxPoint2D temp2 ;
8428 PyObject * obj0 = 0 ;
8429 PyObject * obj1 = 0 ;
8430 char * kwnames[] = {
8431 (char *) "self",(char *) "pt", NULL
8432 };
8433
8434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8436 if (!SWIG_IsOK(res1)) {
8437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8438 }
8439 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8440 {
8441 arg2 = &temp2;
8442 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8443 }
8444 {
8445 PyThreadState* __tstate = wxPyBeginAllowThreads();
8446 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_From_double(static_cast< double >(result));
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 wxPoint2D *arg2 = 0 ;
8461 double result;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 wxPoint2D temp2 ;
8465 PyObject * obj0 = 0 ;
8466 PyObject * obj1 = 0 ;
8467 char * kwnames[] = {
8468 (char *) "self",(char *) "vec", NULL
8469 };
8470
8471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8475 }
8476 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8477 {
8478 arg2 = &temp2;
8479 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8480 }
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 resultobj = SWIG_From_double(static_cast< double >(result));
8488 return resultobj;
8489 fail:
8490 return NULL;
8491 }
8492
8493
8494 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj = 0;
8496 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8497 wxPoint2D *arg2 = 0 ;
8498 double result;
8499 void *argp1 = 0 ;
8500 int res1 = 0 ;
8501 wxPoint2D temp2 ;
8502 PyObject * obj0 = 0 ;
8503 PyObject * obj1 = 0 ;
8504 char * kwnames[] = {
8505 (char *) "self",(char *) "vec", NULL
8506 };
8507
8508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8510 if (!SWIG_IsOK(res1)) {
8511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8512 }
8513 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8514 {
8515 arg2 = &temp2;
8516 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8517 }
8518 {
8519 PyThreadState* __tstate = wxPyBeginAllowThreads();
8520 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 resultobj = SWIG_From_double(static_cast< double >(result));
8525 return resultobj;
8526 fail:
8527 return NULL;
8528 }
8529
8530
8531 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8532 PyObject *resultobj = 0;
8533 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8534 wxPoint2D result;
8535 void *argp1 = 0 ;
8536 int res1 = 0 ;
8537 PyObject *swig_obj[1] ;
8538
8539 if (!args) SWIG_fail;
8540 swig_obj[0] = args;
8541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8542 if (!SWIG_IsOK(res1)) {
8543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8544 }
8545 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8546 {
8547 PyThreadState* __tstate = wxPyBeginAllowThreads();
8548 result = (arg1)->operator -();
8549 wxPyEndAllowThreads(__tstate);
8550 if (PyErr_Occurred()) SWIG_fail;
8551 }
8552 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj = 0;
8561 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8562 wxPoint2D *arg2 = 0 ;
8563 wxPoint2D *result = 0 ;
8564 void *argp1 = 0 ;
8565 int res1 = 0 ;
8566 wxPoint2D temp2 ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 char * kwnames[] = {
8570 (char *) "self",(char *) "pt", NULL
8571 };
8572
8573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8575 if (!SWIG_IsOK(res1)) {
8576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8577 }
8578 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8579 {
8580 arg2 = &temp2;
8581 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8582 }
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 {
8586 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8587 result = (wxPoint2D *) &_result_ref;
8588 }
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj = 0;
8601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8602 wxPoint2D *arg2 = 0 ;
8603 wxPoint2D *result = 0 ;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 wxPoint2D temp2 ;
8607 PyObject * obj0 = 0 ;
8608 PyObject * obj1 = 0 ;
8609 char * kwnames[] = {
8610 (char *) "self",(char *) "pt", NULL
8611 };
8612
8613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8615 if (!SWIG_IsOK(res1)) {
8616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8617 }
8618 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8619 {
8620 arg2 = &temp2;
8621 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8622 }
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 {
8626 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8627 result = (wxPoint2D *) &_result_ref;
8628 }
8629 wxPyEndAllowThreads(__tstate);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8633 return resultobj;
8634 fail:
8635 return NULL;
8636 }
8637
8638
8639 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8640 PyObject *resultobj = 0;
8641 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8642 wxPoint2D *arg2 = 0 ;
8643 wxPoint2D *result = 0 ;
8644 void *argp1 = 0 ;
8645 int res1 = 0 ;
8646 wxPoint2D temp2 ;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char * kwnames[] = {
8650 (char *) "self",(char *) "pt", NULL
8651 };
8652
8653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8655 if (!SWIG_IsOK(res1)) {
8656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8657 }
8658 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8659 {
8660 arg2 = &temp2;
8661 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8662 }
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 {
8666 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8667 result = (wxPoint2D *) &_result_ref;
8668 }
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj = 0;
8681 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8682 wxPoint2D *arg2 = 0 ;
8683 wxPoint2D *result = 0 ;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 wxPoint2D temp2 ;
8687 PyObject * obj0 = 0 ;
8688 PyObject * obj1 = 0 ;
8689 char * kwnames[] = {
8690 (char *) "self",(char *) "pt", NULL
8691 };
8692
8693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8697 }
8698 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8699 {
8700 arg2 = &temp2;
8701 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8702 }
8703 {
8704 PyThreadState* __tstate = wxPyBeginAllowThreads();
8705 {
8706 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8707 result = (wxPoint2D *) &_result_ref;
8708 }
8709 wxPyEndAllowThreads(__tstate);
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj = 0;
8721 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8722 PyObject *arg2 = (PyObject *) 0 ;
8723 bool result;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 PyObject * obj0 = 0 ;
8727 PyObject * obj1 = 0 ;
8728 char * kwnames[] = {
8729 (char *) "self",(char *) "other", NULL
8730 };
8731
8732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8736 }
8737 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8738 arg2 = obj1;
8739 {
8740 result = (bool)wxPoint2D___eq__(arg1,arg2);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 {
8744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8745 }
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj = 0;
8754 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8755 PyObject *arg2 = (PyObject *) 0 ;
8756 bool result;
8757 void *argp1 = 0 ;
8758 int res1 = 0 ;
8759 PyObject * obj0 = 0 ;
8760 PyObject * obj1 = 0 ;
8761 char * kwnames[] = {
8762 (char *) "self",(char *) "other", NULL
8763 };
8764
8765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8769 }
8770 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8771 arg2 = obj1;
8772 {
8773 result = (bool)wxPoint2D___ne__(arg1,arg2);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 {
8777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8778 }
8779 return resultobj;
8780 fail:
8781 return NULL;
8782 }
8783
8784
8785 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8786 PyObject *resultobj = 0;
8787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8788 double arg2 ;
8789 void *argp1 = 0 ;
8790 int res1 = 0 ;
8791 double val2 ;
8792 int ecode2 = 0 ;
8793 PyObject *swig_obj[2] ;
8794
8795 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8797 if (!SWIG_IsOK(res1)) {
8798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8799 }
8800 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8801 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8802 if (!SWIG_IsOK(ecode2)) {
8803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8804 }
8805 arg2 = static_cast< double >(val2);
8806 if (arg1) (arg1)->m_x = arg2;
8807
8808 resultobj = SWIG_Py_Void();
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8816 PyObject *resultobj = 0;
8817 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8818 double result;
8819 void *argp1 = 0 ;
8820 int res1 = 0 ;
8821 PyObject *swig_obj[1] ;
8822
8823 if (!args) SWIG_fail;
8824 swig_obj[0] = args;
8825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8826 if (!SWIG_IsOK(res1)) {
8827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8828 }
8829 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8830 result = (double) ((arg1)->m_x);
8831 resultobj = SWIG_From_double(static_cast< double >(result));
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8839 PyObject *resultobj = 0;
8840 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8841 double arg2 ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 double val2 ;
8845 int ecode2 = 0 ;
8846 PyObject *swig_obj[2] ;
8847
8848 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8850 if (!SWIG_IsOK(res1)) {
8851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8852 }
8853 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8854 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8855 if (!SWIG_IsOK(ecode2)) {
8856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8857 }
8858 arg2 = static_cast< double >(val2);
8859 if (arg1) (arg1)->m_y = arg2;
8860
8861 resultobj = SWIG_Py_Void();
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869 PyObject *resultobj = 0;
8870 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8871 double result;
8872 void *argp1 = 0 ;
8873 int res1 = 0 ;
8874 PyObject *swig_obj[1] ;
8875
8876 if (!args) SWIG_fail;
8877 swig_obj[0] = args;
8878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8879 if (!SWIG_IsOK(res1)) {
8880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8881 }
8882 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8883 result = (double) ((arg1)->m_y);
8884 resultobj = SWIG_From_double(static_cast< double >(result));
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8894 double arg2 = (double) 0 ;
8895 double arg3 = (double) 0 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 double val2 ;
8899 int ecode2 = 0 ;
8900 double val3 ;
8901 int ecode3 = 0 ;
8902 PyObject * obj0 = 0 ;
8903 PyObject * obj1 = 0 ;
8904 PyObject * obj2 = 0 ;
8905 char * kwnames[] = {
8906 (char *) "self",(char *) "x",(char *) "y", NULL
8907 };
8908
8909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8911 if (!SWIG_IsOK(res1)) {
8912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8913 }
8914 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8915 if (obj1) {
8916 ecode2 = SWIG_AsVal_double(obj1, &val2);
8917 if (!SWIG_IsOK(ecode2)) {
8918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8919 }
8920 arg2 = static_cast< double >(val2);
8921 }
8922 if (obj2) {
8923 ecode3 = SWIG_AsVal_double(obj2, &val3);
8924 if (!SWIG_IsOK(ecode3)) {
8925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8926 }
8927 arg3 = static_cast< double >(val3);
8928 }
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 wxPoint2D_Set(arg1,arg2,arg3);
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 resultobj = SWIG_Py_Void();
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943 PyObject *resultobj = 0;
8944 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8945 PyObject *result = 0 ;
8946 void *argp1 = 0 ;
8947 int res1 = 0 ;
8948 PyObject *swig_obj[1] ;
8949
8950 if (!args) SWIG_fail;
8951 swig_obj[0] = args;
8952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8953 if (!SWIG_IsOK(res1)) {
8954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8955 }
8956 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8957 {
8958 PyThreadState* __tstate = wxPyBeginAllowThreads();
8959 result = (PyObject *)wxPoint2D_Get(arg1);
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = result;
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8971 PyObject *obj;
8972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8973 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8974 return SWIG_Py_Void();
8975 }
8976
8977 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978 return SWIG_Python_InitShadowInstance(args);
8979 }
8980
8981 SWIGINTERN int DefaultPosition_set(PyObject *) {
8982 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8983 return 1;
8984 }
8985
8986
8987 SWIGINTERN PyObject *DefaultPosition_get(void) {
8988 PyObject *pyobj = 0;
8989
8990 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8991 return pyobj;
8992 }
8993
8994
8995 SWIGINTERN int DefaultSize_set(PyObject *) {
8996 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8997 return 1;
8998 }
8999
9000
9001 SWIGINTERN PyObject *DefaultSize_get(void) {
9002 PyObject *pyobj = 0;
9003
9004 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9005 return pyobj;
9006 }
9007
9008
9009 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9010 PyObject *resultobj = 0;
9011 PyObject *arg1 = (PyObject *) 0 ;
9012 wxPyInputStream *result = 0 ;
9013 PyObject * obj0 = 0 ;
9014 char * kwnames[] = {
9015 (char *) "p", NULL
9016 };
9017
9018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9019 arg1 = obj0;
9020 {
9021 PyThreadState* __tstate = wxPyBeginAllowThreads();
9022 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 PyObject *resultobj = 0;
9035 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9036 void *argp1 = 0 ;
9037 int res1 = 0 ;
9038 PyObject *swig_obj[1] ;
9039
9040 if (!args) SWIG_fail;
9041 swig_obj[0] = args;
9042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9043 if (!SWIG_IsOK(res1)) {
9044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9045 }
9046 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9047 {
9048 PyThreadState* __tstate = wxPyBeginAllowThreads();
9049 delete arg1;
9050
9051 wxPyEndAllowThreads(__tstate);
9052 if (PyErr_Occurred()) SWIG_fail;
9053 }
9054 resultobj = SWIG_Py_Void();
9055 return resultobj;
9056 fail:
9057 return NULL;
9058 }
9059
9060
9061 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9062 PyObject *resultobj = 0;
9063 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9064 void *argp1 = 0 ;
9065 int res1 = 0 ;
9066 PyObject *swig_obj[1] ;
9067
9068 if (!args) SWIG_fail;
9069 swig_obj[0] = args;
9070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9071 if (!SWIG_IsOK(res1)) {
9072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9073 }
9074 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 (arg1)->close();
9078 wxPyEndAllowThreads(__tstate);
9079 if (PyErr_Occurred()) SWIG_fail;
9080 }
9081 resultobj = SWIG_Py_Void();
9082 return resultobj;
9083 fail:
9084 return NULL;
9085 }
9086
9087
9088 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9089 PyObject *resultobj = 0;
9090 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9091 void *argp1 = 0 ;
9092 int res1 = 0 ;
9093 PyObject *swig_obj[1] ;
9094
9095 if (!args) SWIG_fail;
9096 swig_obj[0] = args;
9097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9098 if (!SWIG_IsOK(res1)) {
9099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9100 }
9101 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 (arg1)->flush();
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 resultobj = SWIG_Py_Void();
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9116 PyObject *resultobj = 0;
9117 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9118 bool result;
9119 void *argp1 = 0 ;
9120 int res1 = 0 ;
9121 PyObject *swig_obj[1] ;
9122
9123 if (!args) SWIG_fail;
9124 swig_obj[0] = args;
9125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9126 if (!SWIG_IsOK(res1)) {
9127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9128 }
9129 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 result = (bool)(arg1)->eof();
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 {
9137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9138 }
9139 return resultobj;
9140 fail:
9141 return NULL;
9142 }
9143
9144
9145 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9146 PyObject *resultobj = 0;
9147 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9148 int arg2 = (int) -1 ;
9149 PyObject *result = 0 ;
9150 void *argp1 = 0 ;
9151 int res1 = 0 ;
9152 int val2 ;
9153 int ecode2 = 0 ;
9154 PyObject * obj0 = 0 ;
9155 PyObject * obj1 = 0 ;
9156 char * kwnames[] = {
9157 (char *) "self",(char *) "size", NULL
9158 };
9159
9160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9162 if (!SWIG_IsOK(res1)) {
9163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9164 }
9165 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9166 if (obj1) {
9167 ecode2 = SWIG_AsVal_int(obj1, &val2);
9168 if (!SWIG_IsOK(ecode2)) {
9169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9170 }
9171 arg2 = static_cast< int >(val2);
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 result = (PyObject *)(arg1)->read(arg2);
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 resultobj = result;
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9187 PyObject *resultobj = 0;
9188 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9189 int arg2 = (int) -1 ;
9190 PyObject *result = 0 ;
9191 void *argp1 = 0 ;
9192 int res1 = 0 ;
9193 int val2 ;
9194 int ecode2 = 0 ;
9195 PyObject * obj0 = 0 ;
9196 PyObject * obj1 = 0 ;
9197 char * kwnames[] = {
9198 (char *) "self",(char *) "size", NULL
9199 };
9200
9201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9203 if (!SWIG_IsOK(res1)) {
9204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9205 }
9206 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9207 if (obj1) {
9208 ecode2 = SWIG_AsVal_int(obj1, &val2);
9209 if (!SWIG_IsOK(ecode2)) {
9210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9211 }
9212 arg2 = static_cast< int >(val2);
9213 }
9214 {
9215 PyThreadState* __tstate = wxPyBeginAllowThreads();
9216 result = (PyObject *)(arg1)->readline(arg2);
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 resultobj = result;
9221 return resultobj;
9222 fail:
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9228 PyObject *resultobj = 0;
9229 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9230 int arg2 = (int) -1 ;
9231 PyObject *result = 0 ;
9232 void *argp1 = 0 ;
9233 int res1 = 0 ;
9234 int val2 ;
9235 int ecode2 = 0 ;
9236 PyObject * obj0 = 0 ;
9237 PyObject * obj1 = 0 ;
9238 char * kwnames[] = {
9239 (char *) "self",(char *) "sizehint", NULL
9240 };
9241
9242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9246 }
9247 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9248 if (obj1) {
9249 ecode2 = SWIG_AsVal_int(obj1, &val2);
9250 if (!SWIG_IsOK(ecode2)) {
9251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9252 }
9253 arg2 = static_cast< int >(val2);
9254 }
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (PyObject *)(arg1)->readlines(arg2);
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 resultobj = result;
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9269 PyObject *resultobj = 0;
9270 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9271 int arg2 ;
9272 int arg3 = (int) 0 ;
9273 void *argp1 = 0 ;
9274 int res1 = 0 ;
9275 int val2 ;
9276 int ecode2 = 0 ;
9277 int val3 ;
9278 int ecode3 = 0 ;
9279 PyObject * obj0 = 0 ;
9280 PyObject * obj1 = 0 ;
9281 PyObject * obj2 = 0 ;
9282 char * kwnames[] = {
9283 (char *) "self",(char *) "offset",(char *) "whence", NULL
9284 };
9285
9286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9290 }
9291 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9292 ecode2 = SWIG_AsVal_int(obj1, &val2);
9293 if (!SWIG_IsOK(ecode2)) {
9294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9295 }
9296 arg2 = static_cast< int >(val2);
9297 if (obj2) {
9298 ecode3 = SWIG_AsVal_int(obj2, &val3);
9299 if (!SWIG_IsOK(ecode3)) {
9300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9301 }
9302 arg3 = static_cast< int >(val3);
9303 }
9304 {
9305 PyThreadState* __tstate = wxPyBeginAllowThreads();
9306 (arg1)->seek(arg2,arg3);
9307 wxPyEndAllowThreads(__tstate);
9308 if (PyErr_Occurred()) SWIG_fail;
9309 }
9310 resultobj = SWIG_Py_Void();
9311 return resultobj;
9312 fail:
9313 return NULL;
9314 }
9315
9316
9317 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9318 PyObject *resultobj = 0;
9319 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9320 int result;
9321 void *argp1 = 0 ;
9322 int res1 = 0 ;
9323 PyObject *swig_obj[1] ;
9324
9325 if (!args) SWIG_fail;
9326 swig_obj[0] = args;
9327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9328 if (!SWIG_IsOK(res1)) {
9329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9330 }
9331 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9332 {
9333 PyThreadState* __tstate = wxPyBeginAllowThreads();
9334 result = (int)(arg1)->tell();
9335 wxPyEndAllowThreads(__tstate);
9336 if (PyErr_Occurred()) SWIG_fail;
9337 }
9338 resultobj = SWIG_From_int(static_cast< int >(result));
9339 return resultobj;
9340 fail:
9341 return NULL;
9342 }
9343
9344
9345 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9346 PyObject *resultobj = 0;
9347 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9348 char result;
9349 void *argp1 = 0 ;
9350 int res1 = 0 ;
9351 PyObject *swig_obj[1] ;
9352
9353 if (!args) SWIG_fail;
9354 swig_obj[0] = args;
9355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9356 if (!SWIG_IsOK(res1)) {
9357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9358 }
9359 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9360 {
9361 PyThreadState* __tstate = wxPyBeginAllowThreads();
9362 result = (char)(arg1)->Peek();
9363 wxPyEndAllowThreads(__tstate);
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 resultobj = SWIG_From_char(static_cast< char >(result));
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9374 PyObject *resultobj = 0;
9375 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9376 char result;
9377 void *argp1 = 0 ;
9378 int res1 = 0 ;
9379 PyObject *swig_obj[1] ;
9380
9381 if (!args) SWIG_fail;
9382 swig_obj[0] = args;
9383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9384 if (!SWIG_IsOK(res1)) {
9385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9386 }
9387 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (char)(arg1)->GetC();
9391 wxPyEndAllowThreads(__tstate);
9392 if (PyErr_Occurred()) SWIG_fail;
9393 }
9394 resultobj = SWIG_From_char(static_cast< char >(result));
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9402 PyObject *resultobj = 0;
9403 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9404 size_t result;
9405 void *argp1 = 0 ;
9406 int res1 = 0 ;
9407 PyObject *swig_obj[1] ;
9408
9409 if (!args) SWIG_fail;
9410 swig_obj[0] = args;
9411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9412 if (!SWIG_IsOK(res1)) {
9413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9414 }
9415 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9416 {
9417 PyThreadState* __tstate = wxPyBeginAllowThreads();
9418 result = (size_t)(arg1)->LastRead();
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9430 PyObject *resultobj = 0;
9431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9432 bool result;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 PyObject *swig_obj[1] ;
9436
9437 if (!args) SWIG_fail;
9438 swig_obj[0] = args;
9439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9442 }
9443 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9444 {
9445 PyThreadState* __tstate = wxPyBeginAllowThreads();
9446 result = (bool)(arg1)->CanRead();
9447 wxPyEndAllowThreads(__tstate);
9448 if (PyErr_Occurred()) SWIG_fail;
9449 }
9450 {
9451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9452 }
9453 return resultobj;
9454 fail:
9455 return NULL;
9456 }
9457
9458
9459 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9460 PyObject *resultobj = 0;
9461 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9462 bool result;
9463 void *argp1 = 0 ;
9464 int res1 = 0 ;
9465 PyObject *swig_obj[1] ;
9466
9467 if (!args) SWIG_fail;
9468 swig_obj[0] = args;
9469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9470 if (!SWIG_IsOK(res1)) {
9471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9472 }
9473 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (bool)(arg1)->Eof();
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 {
9481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9482 }
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj = 0;
9491 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9492 char arg2 ;
9493 bool result;
9494 void *argp1 = 0 ;
9495 int res1 = 0 ;
9496 char val2 ;
9497 int ecode2 = 0 ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 char * kwnames[] = {
9501 (char *) "self",(char *) "c", NULL
9502 };
9503
9504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9506 if (!SWIG_IsOK(res1)) {
9507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9508 }
9509 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9510 ecode2 = SWIG_AsVal_char(obj1, &val2);
9511 if (!SWIG_IsOK(ecode2)) {
9512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9513 }
9514 arg2 = static_cast< char >(val2);
9515 {
9516 PyThreadState* __tstate = wxPyBeginAllowThreads();
9517 result = (bool)(arg1)->Ungetch(arg2);
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 {
9522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9523 }
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9531 PyObject *resultobj = 0;
9532 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9533 long arg2 ;
9534 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9535 long result;
9536 void *argp1 = 0 ;
9537 int res1 = 0 ;
9538 long val2 ;
9539 int ecode2 = 0 ;
9540 int val3 ;
9541 int ecode3 = 0 ;
9542 PyObject * obj0 = 0 ;
9543 PyObject * obj1 = 0 ;
9544 PyObject * obj2 = 0 ;
9545 char * kwnames[] = {
9546 (char *) "self",(char *) "pos",(char *) "mode", NULL
9547 };
9548
9549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9551 if (!SWIG_IsOK(res1)) {
9552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9553 }
9554 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9555 ecode2 = SWIG_AsVal_long(obj1, &val2);
9556 if (!SWIG_IsOK(ecode2)) {
9557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9558 }
9559 arg2 = static_cast< long >(val2);
9560 if (obj2) {
9561 ecode3 = SWIG_AsVal_int(obj2, &val3);
9562 if (!SWIG_IsOK(ecode3)) {
9563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9564 }
9565 arg3 = static_cast< wxSeekMode >(val3);
9566 }
9567 {
9568 PyThreadState* __tstate = wxPyBeginAllowThreads();
9569 result = (long)(arg1)->SeekI(arg2,arg3);
9570 wxPyEndAllowThreads(__tstate);
9571 if (PyErr_Occurred()) SWIG_fail;
9572 }
9573 resultobj = SWIG_From_long(static_cast< long >(result));
9574 return resultobj;
9575 fail:
9576 return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9581 PyObject *resultobj = 0;
9582 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9583 long result;
9584 void *argp1 = 0 ;
9585 int res1 = 0 ;
9586 PyObject *swig_obj[1] ;
9587
9588 if (!args) SWIG_fail;
9589 swig_obj[0] = args;
9590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9591 if (!SWIG_IsOK(res1)) {
9592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9593 }
9594 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 result = (long)(arg1)->TellI();
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_From_long(static_cast< long >(result));
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609 PyObject *obj;
9610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9612 return SWIG_Py_Void();
9613 }
9614
9615 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9616 return SWIG_Python_InitShadowInstance(args);
9617 }
9618
9619 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj = 0;
9621 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9622 PyObject *arg2 = (PyObject *) 0 ;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 PyObject * obj0 = 0 ;
9626 PyObject * obj1 = 0 ;
9627 char * kwnames[] = {
9628 (char *) "self",(char *) "obj", NULL
9629 };
9630
9631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9633 if (!SWIG_IsOK(res1)) {
9634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9635 }
9636 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9637 arg2 = obj1;
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 wxOutputStream_write(arg1,arg2);
9641 wxPyEndAllowThreads(__tstate);
9642 if (PyErr_Occurred()) SWIG_fail;
9643 }
9644 resultobj = SWIG_Py_Void();
9645 return resultobj;
9646 fail:
9647 return NULL;
9648 }
9649
9650
9651 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9652 PyObject *resultobj = 0;
9653 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9654 size_t result;
9655 void *argp1 = 0 ;
9656 int res1 = 0 ;
9657 PyObject *swig_obj[1] ;
9658
9659 if (!args) SWIG_fail;
9660 swig_obj[0] = args;
9661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9662 if (!SWIG_IsOK(res1)) {
9663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9664 }
9665 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9666 {
9667 PyThreadState* __tstate = wxPyBeginAllowThreads();
9668 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9669 wxPyEndAllowThreads(__tstate);
9670 if (PyErr_Occurred()) SWIG_fail;
9671 }
9672 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9673 return resultobj;
9674 fail:
9675 return NULL;
9676 }
9677
9678
9679 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9680 PyObject *obj;
9681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9682 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9683 return SWIG_Py_Void();
9684 }
9685
9686 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9687 PyObject *resultobj = 0;
9688 wxInputStream *arg1 = (wxInputStream *) 0 ;
9689 wxString *arg2 = 0 ;
9690 wxString *arg3 = 0 ;
9691 wxString *arg4 = 0 ;
9692 wxDateTime arg5 ;
9693 wxFSFile *result = 0 ;
9694 wxPyInputStream *temp1 ;
9695 bool temp2 = false ;
9696 bool temp3 = false ;
9697 bool temp4 = false ;
9698 void *argp5 ;
9699 int res5 = 0 ;
9700 PyObject * obj0 = 0 ;
9701 PyObject * obj1 = 0 ;
9702 PyObject * obj2 = 0 ;
9703 PyObject * obj3 = 0 ;
9704 PyObject * obj4 = 0 ;
9705 char * kwnames[] = {
9706 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9707 };
9708
9709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9710 {
9711 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9712 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9713 } else {
9714 PyErr_Clear(); // clear the failure of the wxPyConvert above
9715 arg1 = wxPyCBInputStream_create(obj0, true);
9716 if (arg1 == NULL) {
9717 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9718 SWIG_fail;
9719 }
9720 }
9721 }
9722 {
9723 arg2 = wxString_in_helper(obj1);
9724 if (arg2 == NULL) SWIG_fail;
9725 temp2 = true;
9726 }
9727 {
9728 arg3 = wxString_in_helper(obj2);
9729 if (arg3 == NULL) SWIG_fail;
9730 temp3 = true;
9731 }
9732 {
9733 arg4 = wxString_in_helper(obj3);
9734 if (arg4 == NULL) SWIG_fail;
9735 temp4 = true;
9736 }
9737 {
9738 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9739 if (!SWIG_IsOK(res5)) {
9740 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9741 }
9742 if (!argp5) {
9743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9744 } else {
9745 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9746 arg5 = *temp;
9747 if (SWIG_IsNewObj(res5)) delete temp;
9748 }
9749 }
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9757 {
9758 if (temp2)
9759 delete arg2;
9760 }
9761 {
9762 if (temp3)
9763 delete arg3;
9764 }
9765 {
9766 if (temp4)
9767 delete arg4;
9768 }
9769 return resultobj;
9770 fail:
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 {
9776 if (temp3)
9777 delete arg3;
9778 }
9779 {
9780 if (temp4)
9781 delete arg4;
9782 }
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9788 PyObject *resultobj = 0;
9789 wxFSFile *arg1 = (wxFSFile *) 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 PyObject *swig_obj[1] ;
9793
9794 if (!args) SWIG_fail;
9795 swig_obj[0] = args;
9796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9797 if (!SWIG_IsOK(res1)) {
9798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9799 }
9800 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 delete arg1;
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 resultobj = SWIG_Py_Void();
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9816 PyObject *resultobj = 0;
9817 wxFSFile *arg1 = (wxFSFile *) 0 ;
9818 wxInputStream *result = 0 ;
9819 void *argp1 = 0 ;
9820 int res1 = 0 ;
9821 PyObject *swig_obj[1] ;
9822
9823 if (!args) SWIG_fail;
9824 swig_obj[0] = args;
9825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9826 if (!SWIG_IsOK(res1)) {
9827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9828 }
9829 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (wxInputStream *)(arg1)->GetStream();
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 {
9837 wxPyInputStream * _ptr = NULL;
9838
9839 if (result) {
9840 _ptr = new wxPyInputStream(result);
9841 }
9842 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9843 }
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9851 PyObject *resultobj = 0;
9852 wxFSFile *arg1 = (wxFSFile *) 0 ;
9853 void *argp1 = 0 ;
9854 int res1 = 0 ;
9855 PyObject *swig_obj[1] ;
9856
9857 if (!args) SWIG_fail;
9858 swig_obj[0] = args;
9859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9860 if (!SWIG_IsOK(res1)) {
9861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9862 }
9863 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9864 {
9865 PyThreadState* __tstate = wxPyBeginAllowThreads();
9866 (arg1)->DetachStream();
9867 wxPyEndAllowThreads(__tstate);
9868 if (PyErr_Occurred()) SWIG_fail;
9869 }
9870 resultobj = SWIG_Py_Void();
9871 return resultobj;
9872 fail:
9873 return NULL;
9874 }
9875
9876
9877 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9878 PyObject *resultobj = 0;
9879 wxFSFile *arg1 = (wxFSFile *) 0 ;
9880 wxString *result = 0 ;
9881 void *argp1 = 0 ;
9882 int res1 = 0 ;
9883 PyObject *swig_obj[1] ;
9884
9885 if (!args) SWIG_fail;
9886 swig_obj[0] = args;
9887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9888 if (!SWIG_IsOK(res1)) {
9889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9890 }
9891 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 {
9895 wxString const &_result_ref = (arg1)->GetMimeType();
9896 result = (wxString *) &_result_ref;
9897 }
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 {
9902 #if wxUSE_UNICODE
9903 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9904 #else
9905 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9906 #endif
9907 }
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9915 PyObject *resultobj = 0;
9916 wxFSFile *arg1 = (wxFSFile *) 0 ;
9917 wxString *result = 0 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 PyObject *swig_obj[1] ;
9921
9922 if (!args) SWIG_fail;
9923 swig_obj[0] = args;
9924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9925 if (!SWIG_IsOK(res1)) {
9926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9927 }
9928 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 {
9932 wxString const &_result_ref = (arg1)->GetLocation();
9933 result = (wxString *) &_result_ref;
9934 }
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 #if wxUSE_UNICODE
9940 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9941 #else
9942 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9943 #endif
9944 }
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9952 PyObject *resultobj = 0;
9953 wxFSFile *arg1 = (wxFSFile *) 0 ;
9954 wxString *result = 0 ;
9955 void *argp1 = 0 ;
9956 int res1 = 0 ;
9957 PyObject *swig_obj[1] ;
9958
9959 if (!args) SWIG_fail;
9960 swig_obj[0] = args;
9961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9962 if (!SWIG_IsOK(res1)) {
9963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9964 }
9965 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 {
9969 wxString const &_result_ref = (arg1)->GetAnchor();
9970 result = (wxString *) &_result_ref;
9971 }
9972 wxPyEndAllowThreads(__tstate);
9973 if (PyErr_Occurred()) SWIG_fail;
9974 }
9975 {
9976 #if wxUSE_UNICODE
9977 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9978 #else
9979 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9980 #endif
9981 }
9982 return resultobj;
9983 fail:
9984 return NULL;
9985 }
9986
9987
9988 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9989 PyObject *resultobj = 0;
9990 wxFSFile *arg1 = (wxFSFile *) 0 ;
9991 wxDateTime result;
9992 void *argp1 = 0 ;
9993 int res1 = 0 ;
9994 PyObject *swig_obj[1] ;
9995
9996 if (!args) SWIG_fail;
9997 swig_obj[0] = args;
9998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9999 if (!SWIG_IsOK(res1)) {
10000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10001 }
10002 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (arg1)->GetModificationTime();
10006 wxPyEndAllowThreads(__tstate);
10007 if (PyErr_Occurred()) SWIG_fail;
10008 }
10009 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10010 return resultobj;
10011 fail:
10012 return NULL;
10013 }
10014
10015
10016 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10017 PyObject *obj;
10018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10019 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10020 return SWIG_Py_Void();
10021 }
10022
10023 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10024 return SWIG_Python_InitShadowInstance(args);
10025 }
10026
10027 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 PyObject *swig_obj[1] ;
10033
10034 if (!args) SWIG_fail;
10035 swig_obj[0] = args;
10036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10039 }
10040 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 delete arg1;
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 resultobj = SWIG_Py_Void();
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10056 PyObject *obj;
10057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10058 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10059 return SWIG_Py_Void();
10060 }
10061
10062 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10063 PyObject *resultobj = 0;
10064 wxPyFileSystemHandler *result = 0 ;
10065
10066 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10067 {
10068 PyThreadState* __tstate = wxPyBeginAllowThreads();
10069 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10070 wxPyEndAllowThreads(__tstate);
10071 if (PyErr_Occurred()) SWIG_fail;
10072 }
10073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10074 return resultobj;
10075 fail:
10076 return NULL;
10077 }
10078
10079
10080 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj = 0;
10082 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10083 PyObject *arg2 = (PyObject *) 0 ;
10084 PyObject *arg3 = (PyObject *) 0 ;
10085 void *argp1 = 0 ;
10086 int res1 = 0 ;
10087 PyObject * obj0 = 0 ;
10088 PyObject * obj1 = 0 ;
10089 PyObject * obj2 = 0 ;
10090 char * kwnames[] = {
10091 (char *) "self",(char *) "self",(char *) "_class", NULL
10092 };
10093
10094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10096 if (!SWIG_IsOK(res1)) {
10097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10098 }
10099 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10100 arg2 = obj1;
10101 arg3 = obj2;
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 (arg1)->_setCallbackInfo(arg2,arg3);
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 resultobj = SWIG_Py_Void();
10109 return resultobj;
10110 fail:
10111 return NULL;
10112 }
10113
10114
10115 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10116 PyObject *resultobj = 0;
10117 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10118 wxString *arg2 = 0 ;
10119 bool result;
10120 void *argp1 = 0 ;
10121 int res1 = 0 ;
10122 bool temp2 = false ;
10123 PyObject * obj0 = 0 ;
10124 PyObject * obj1 = 0 ;
10125 char * kwnames[] = {
10126 (char *) "self",(char *) "location", NULL
10127 };
10128
10129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10131 if (!SWIG_IsOK(res1)) {
10132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10133 }
10134 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10135 {
10136 arg2 = wxString_in_helper(obj1);
10137 if (arg2 == NULL) SWIG_fail;
10138 temp2 = true;
10139 }
10140 {
10141 PyThreadState* __tstate = wxPyBeginAllowThreads();
10142 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10143 wxPyEndAllowThreads(__tstate);
10144 if (PyErr_Occurred()) SWIG_fail;
10145 }
10146 {
10147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10148 }
10149 {
10150 if (temp2)
10151 delete arg2;
10152 }
10153 return resultobj;
10154 fail:
10155 {
10156 if (temp2)
10157 delete arg2;
10158 }
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10166 wxFileSystem *arg2 = 0 ;
10167 wxString *arg3 = 0 ;
10168 wxFSFile *result = 0 ;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 void *argp2 = 0 ;
10172 int res2 = 0 ;
10173 bool temp3 = false ;
10174 PyObject * obj0 = 0 ;
10175 PyObject * obj1 = 0 ;
10176 PyObject * obj2 = 0 ;
10177 char * kwnames[] = {
10178 (char *) "self",(char *) "fs",(char *) "location", NULL
10179 };
10180
10181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10185 }
10186 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10188 if (!SWIG_IsOK(res2)) {
10189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10190 }
10191 if (!argp2) {
10192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10193 }
10194 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10195 {
10196 arg3 = wxString_in_helper(obj2);
10197 if (arg3 == NULL) SWIG_fail;
10198 temp3 = true;
10199 }
10200 {
10201 PyThreadState* __tstate = wxPyBeginAllowThreads();
10202 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10203 wxPyEndAllowThreads(__tstate);
10204 if (PyErr_Occurred()) SWIG_fail;
10205 }
10206 {
10207 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10208 }
10209 {
10210 if (temp3)
10211 delete arg3;
10212 }
10213 return resultobj;
10214 fail:
10215 {
10216 if (temp3)
10217 delete arg3;
10218 }
10219 return NULL;
10220 }
10221
10222
10223 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10224 PyObject *resultobj = 0;
10225 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10226 wxString *arg2 = 0 ;
10227 int arg3 = (int) 0 ;
10228 wxString result;
10229 void *argp1 = 0 ;
10230 int res1 = 0 ;
10231 bool temp2 = false ;
10232 int val3 ;
10233 int ecode3 = 0 ;
10234 PyObject * obj0 = 0 ;
10235 PyObject * obj1 = 0 ;
10236 PyObject * obj2 = 0 ;
10237 char * kwnames[] = {
10238 (char *) "self",(char *) "spec",(char *) "flags", NULL
10239 };
10240
10241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10243 if (!SWIG_IsOK(res1)) {
10244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10245 }
10246 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10247 {
10248 arg2 = wxString_in_helper(obj1);
10249 if (arg2 == NULL) SWIG_fail;
10250 temp2 = true;
10251 }
10252 if (obj2) {
10253 ecode3 = SWIG_AsVal_int(obj2, &val3);
10254 if (!SWIG_IsOK(ecode3)) {
10255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10256 }
10257 arg3 = static_cast< int >(val3);
10258 }
10259 {
10260 PyThreadState* __tstate = wxPyBeginAllowThreads();
10261 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
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_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10287 PyObject *resultobj = 0;
10288 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10289 wxString result;
10290 void *argp1 = 0 ;
10291 int res1 = 0 ;
10292 PyObject *swig_obj[1] ;
10293
10294 if (!args) SWIG_fail;
10295 swig_obj[0] = args;
10296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10297 if (!SWIG_IsOK(res1)) {
10298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10299 }
10300 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10301 {
10302 PyThreadState* __tstate = wxPyBeginAllowThreads();
10303 result = (arg1)->FindNext();
10304 wxPyEndAllowThreads(__tstate);
10305 if (PyErr_Occurred()) SWIG_fail;
10306 }
10307 {
10308 #if wxUSE_UNICODE
10309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10310 #else
10311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10312 #endif
10313 }
10314 return resultobj;
10315 fail:
10316 return NULL;
10317 }
10318
10319
10320 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10321 PyObject *resultobj = 0;
10322 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10323 wxString *arg2 = 0 ;
10324 wxString result;
10325 void *argp1 = 0 ;
10326 int res1 = 0 ;
10327 bool temp2 = false ;
10328 PyObject * obj0 = 0 ;
10329 PyObject * obj1 = 0 ;
10330 char * kwnames[] = {
10331 (char *) "self",(char *) "location", NULL
10332 };
10333
10334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10336 if (!SWIG_IsOK(res1)) {
10337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10338 }
10339 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10340 {
10341 arg2 = wxString_in_helper(obj1);
10342 if (arg2 == NULL) SWIG_fail;
10343 temp2 = true;
10344 }
10345 {
10346 PyThreadState* __tstate = wxPyBeginAllowThreads();
10347 result = (arg1)->GetProtocol((wxString const &)*arg2);
10348 wxPyEndAllowThreads(__tstate);
10349 if (PyErr_Occurred()) SWIG_fail;
10350 }
10351 {
10352 #if wxUSE_UNICODE
10353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10354 #else
10355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10356 #endif
10357 }
10358 {
10359 if (temp2)
10360 delete arg2;
10361 }
10362 return resultobj;
10363 fail:
10364 {
10365 if (temp2)
10366 delete arg2;
10367 }
10368 return NULL;
10369 }
10370
10371
10372 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10373 PyObject *resultobj = 0;
10374 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10375 wxString *arg2 = 0 ;
10376 wxString result;
10377 void *argp1 = 0 ;
10378 int res1 = 0 ;
10379 bool temp2 = false ;
10380 PyObject * obj0 = 0 ;
10381 PyObject * obj1 = 0 ;
10382 char * kwnames[] = {
10383 (char *) "self",(char *) "location", NULL
10384 };
10385
10386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10388 if (!SWIG_IsOK(res1)) {
10389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10390 }
10391 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10392 {
10393 arg2 = wxString_in_helper(obj1);
10394 if (arg2 == NULL) SWIG_fail;
10395 temp2 = true;
10396 }
10397 {
10398 PyThreadState* __tstate = wxPyBeginAllowThreads();
10399 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10400 wxPyEndAllowThreads(__tstate);
10401 if (PyErr_Occurred()) SWIG_fail;
10402 }
10403 {
10404 #if wxUSE_UNICODE
10405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10406 #else
10407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10408 #endif
10409 }
10410 {
10411 if (temp2)
10412 delete arg2;
10413 }
10414 return resultobj;
10415 fail:
10416 {
10417 if (temp2)
10418 delete arg2;
10419 }
10420 return NULL;
10421 }
10422
10423
10424 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10425 PyObject *resultobj = 0;
10426 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10427 wxString *arg2 = 0 ;
10428 wxString result;
10429 void *argp1 = 0 ;
10430 int res1 = 0 ;
10431 bool temp2 = false ;
10432 PyObject * obj0 = 0 ;
10433 PyObject * obj1 = 0 ;
10434 char * kwnames[] = {
10435 (char *) "self",(char *) "location", NULL
10436 };
10437
10438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10440 if (!SWIG_IsOK(res1)) {
10441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10442 }
10443 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10444 {
10445 arg2 = wxString_in_helper(obj1);
10446 if (arg2 == NULL) SWIG_fail;
10447 temp2 = true;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (arg1)->GetAnchor((wxString const &)*arg2);
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 {
10456 #if wxUSE_UNICODE
10457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10458 #else
10459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10460 #endif
10461 }
10462 {
10463 if (temp2)
10464 delete arg2;
10465 }
10466 return resultobj;
10467 fail:
10468 {
10469 if (temp2)
10470 delete arg2;
10471 }
10472 return NULL;
10473 }
10474
10475
10476 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10477 PyObject *resultobj = 0;
10478 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10479 wxString *arg2 = 0 ;
10480 wxString result;
10481 void *argp1 = 0 ;
10482 int res1 = 0 ;
10483 bool temp2 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 char * kwnames[] = {
10487 (char *) "self",(char *) "location", NULL
10488 };
10489
10490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10492 if (!SWIG_IsOK(res1)) {
10493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10494 }
10495 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10496 {
10497 arg2 = wxString_in_helper(obj1);
10498 if (arg2 == NULL) SWIG_fail;
10499 temp2 = true;
10500 }
10501 {
10502 PyThreadState* __tstate = wxPyBeginAllowThreads();
10503 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10504 wxPyEndAllowThreads(__tstate);
10505 if (PyErr_Occurred()) SWIG_fail;
10506 }
10507 {
10508 #if wxUSE_UNICODE
10509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10510 #else
10511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10512 #endif
10513 }
10514 {
10515 if (temp2)
10516 delete arg2;
10517 }
10518 return resultobj;
10519 fail:
10520 {
10521 if (temp2)
10522 delete arg2;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj = 0;
10530 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10531 wxString *arg2 = 0 ;
10532 wxString result;
10533 void *argp1 = 0 ;
10534 int res1 = 0 ;
10535 bool temp2 = false ;
10536 PyObject * obj0 = 0 ;
10537 PyObject * obj1 = 0 ;
10538 char * kwnames[] = {
10539 (char *) "self",(char *) "location", NULL
10540 };
10541
10542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10544 if (!SWIG_IsOK(res1)) {
10545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10546 }
10547 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10548 {
10549 arg2 = wxString_in_helper(obj1);
10550 if (arg2 == NULL) SWIG_fail;
10551 temp2 = true;
10552 }
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10556 wxPyEndAllowThreads(__tstate);
10557 if (PyErr_Occurred()) SWIG_fail;
10558 }
10559 {
10560 #if wxUSE_UNICODE
10561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10562 #else
10563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10564 #endif
10565 }
10566 {
10567 if (temp2)
10568 delete arg2;
10569 }
10570 return resultobj;
10571 fail:
10572 {
10573 if (temp2)
10574 delete arg2;
10575 }
10576 return NULL;
10577 }
10578
10579
10580 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10581 PyObject *obj;
10582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10583 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10584 return SWIG_Py_Void();
10585 }
10586
10587 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10588 return SWIG_Python_InitShadowInstance(args);
10589 }
10590
10591 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10592 PyObject *resultobj = 0;
10593 wxFileSystem *result = 0 ;
10594
10595 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10596 {
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 result = (wxFileSystem *)new wxFileSystem();
10599 wxPyEndAllowThreads(__tstate);
10600 if (PyErr_Occurred()) SWIG_fail;
10601 }
10602 {
10603 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10604 }
10605 return resultobj;
10606 fail:
10607 return NULL;
10608 }
10609
10610
10611 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10612 PyObject *resultobj = 0;
10613 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10614 void *argp1 = 0 ;
10615 int res1 = 0 ;
10616 PyObject *swig_obj[1] ;
10617
10618 if (!args) SWIG_fail;
10619 swig_obj[0] = args;
10620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10621 if (!SWIG_IsOK(res1)) {
10622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10623 }
10624 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 delete arg1;
10628
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 resultobj = SWIG_Py_Void();
10633 return resultobj;
10634 fail:
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = 0;
10641 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10642 wxString *arg2 = 0 ;
10643 bool arg3 = (bool) false ;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 bool temp2 = false ;
10647 bool val3 ;
10648 int ecode3 = 0 ;
10649 PyObject * obj0 = 0 ;
10650 PyObject * obj1 = 0 ;
10651 PyObject * obj2 = 0 ;
10652 char * kwnames[] = {
10653 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10654 };
10655
10656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10658 if (!SWIG_IsOK(res1)) {
10659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10660 }
10661 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10662 {
10663 arg2 = wxString_in_helper(obj1);
10664 if (arg2 == NULL) SWIG_fail;
10665 temp2 = true;
10666 }
10667 if (obj2) {
10668 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10669 if (!SWIG_IsOK(ecode3)) {
10670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10671 }
10672 arg3 = static_cast< bool >(val3);
10673 }
10674 {
10675 PyThreadState* __tstate = wxPyBeginAllowThreads();
10676 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10677 wxPyEndAllowThreads(__tstate);
10678 if (PyErr_Occurred()) SWIG_fail;
10679 }
10680 resultobj = SWIG_Py_Void();
10681 {
10682 if (temp2)
10683 delete arg2;
10684 }
10685 return resultobj;
10686 fail:
10687 {
10688 if (temp2)
10689 delete arg2;
10690 }
10691 return NULL;
10692 }
10693
10694
10695 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696 PyObject *resultobj = 0;
10697 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10698 wxString result;
10699 void *argp1 = 0 ;
10700 int res1 = 0 ;
10701 PyObject *swig_obj[1] ;
10702
10703 if (!args) SWIG_fail;
10704 swig_obj[0] = args;
10705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10708 }
10709 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (arg1)->GetPath();
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 {
10717 #if wxUSE_UNICODE
10718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10719 #else
10720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10721 #endif
10722 }
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj = 0;
10731 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10732 wxString *arg2 = 0 ;
10733 wxFSFile *result = 0 ;
10734 void *argp1 = 0 ;
10735 int res1 = 0 ;
10736 bool temp2 = false ;
10737 PyObject * obj0 = 0 ;
10738 PyObject * obj1 = 0 ;
10739 char * kwnames[] = {
10740 (char *) "self",(char *) "location", NULL
10741 };
10742
10743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10745 if (!SWIG_IsOK(res1)) {
10746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10747 }
10748 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10749 {
10750 arg2 = wxString_in_helper(obj1);
10751 if (arg2 == NULL) SWIG_fail;
10752 temp2 = true;
10753 }
10754 {
10755 PyThreadState* __tstate = wxPyBeginAllowThreads();
10756 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 {
10761 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10762 }
10763 {
10764 if (temp2)
10765 delete arg2;
10766 }
10767 return resultobj;
10768 fail:
10769 {
10770 if (temp2)
10771 delete arg2;
10772 }
10773 return NULL;
10774 }
10775
10776
10777 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10778 PyObject *resultobj = 0;
10779 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10780 wxString *arg2 = 0 ;
10781 int arg3 = (int) 0 ;
10782 wxString result;
10783 void *argp1 = 0 ;
10784 int res1 = 0 ;
10785 bool temp2 = false ;
10786 int val3 ;
10787 int ecode3 = 0 ;
10788 PyObject * obj0 = 0 ;
10789 PyObject * obj1 = 0 ;
10790 PyObject * obj2 = 0 ;
10791 char * kwnames[] = {
10792 (char *) "self",(char *) "spec",(char *) "flags", NULL
10793 };
10794
10795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10797 if (!SWIG_IsOK(res1)) {
10798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10799 }
10800 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10801 {
10802 arg2 = wxString_in_helper(obj1);
10803 if (arg2 == NULL) SWIG_fail;
10804 temp2 = true;
10805 }
10806 if (obj2) {
10807 ecode3 = SWIG_AsVal_int(obj2, &val3);
10808 if (!SWIG_IsOK(ecode3)) {
10809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10810 }
10811 arg3 = static_cast< int >(val3);
10812 }
10813 {
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 {
10820 #if wxUSE_UNICODE
10821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10822 #else
10823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10824 #endif
10825 }
10826 {
10827 if (temp2)
10828 delete arg2;
10829 }
10830 return resultobj;
10831 fail:
10832 {
10833 if (temp2)
10834 delete arg2;
10835 }
10836 return NULL;
10837 }
10838
10839
10840 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10841 PyObject *resultobj = 0;
10842 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10843 wxString result;
10844 void *argp1 = 0 ;
10845 int res1 = 0 ;
10846 PyObject *swig_obj[1] ;
10847
10848 if (!args) SWIG_fail;
10849 swig_obj[0] = args;
10850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10851 if (!SWIG_IsOK(res1)) {
10852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10853 }
10854 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10855 {
10856 PyThreadState* __tstate = wxPyBeginAllowThreads();
10857 result = (arg1)->FindNext();
10858 wxPyEndAllowThreads(__tstate);
10859 if (PyErr_Occurred()) SWIG_fail;
10860 }
10861 {
10862 #if wxUSE_UNICODE
10863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10864 #else
10865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10866 #endif
10867 }
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10877 int res1 = 0 ;
10878 PyObject * obj0 = 0 ;
10879 char * kwnames[] = {
10880 (char *) "handler", NULL
10881 };
10882
10883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10884 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10885 if (!SWIG_IsOK(res1)) {
10886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10887 }
10888 {
10889 PyThreadState* __tstate = wxPyBeginAllowThreads();
10890 wxFileSystem::AddHandler(arg1);
10891 wxPyEndAllowThreads(__tstate);
10892 if (PyErr_Occurred()) SWIG_fail;
10893 }
10894 resultobj = SWIG_Py_Void();
10895 return resultobj;
10896 fail:
10897 return NULL;
10898 }
10899
10900
10901 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10902 PyObject *resultobj = 0;
10903 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10904 wxFileSystemHandler *result = 0 ;
10905 void *argp1 = 0 ;
10906 int res1 = 0 ;
10907 PyObject * obj0 = 0 ;
10908 char * kwnames[] = {
10909 (char *) "handler", NULL
10910 };
10911
10912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10914 if (!SWIG_IsOK(res1)) {
10915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10916 }
10917 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10918 {
10919 PyThreadState* __tstate = wxPyBeginAllowThreads();
10920 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10921 wxPyEndAllowThreads(__tstate);
10922 if (PyErr_Occurred()) SWIG_fail;
10923 }
10924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10932 PyObject *resultobj = 0;
10933
10934 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 wxFileSystem::CleanUpHandlers();
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 resultobj = SWIG_Py_Void();
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxString *arg1 = 0 ;
10951 wxString result;
10952 bool temp1 = false ;
10953 PyObject * obj0 = 0 ;
10954 char * kwnames[] = {
10955 (char *) "filename", NULL
10956 };
10957
10958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10959 {
10960 arg1 = wxString_in_helper(obj0);
10961 if (arg1 == NULL) SWIG_fail;
10962 temp1 = true;
10963 }
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 #if wxUSE_UNICODE
10972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10973 #else
10974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10975 #endif
10976 }
10977 {
10978 if (temp1)
10979 delete arg1;
10980 }
10981 return resultobj;
10982 fail:
10983 {
10984 if (temp1)
10985 delete arg1;
10986 }
10987 return NULL;
10988 }
10989
10990
10991 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10992 PyObject *resultobj = 0;
10993 wxString *arg1 = 0 ;
10994 wxString result;
10995 bool temp1 = false ;
10996 PyObject * obj0 = 0 ;
10997 char * kwnames[] = {
10998 (char *) "url", NULL
10999 };
11000
11001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11002 {
11003 arg1 = wxString_in_helper(obj0);
11004 if (arg1 == NULL) SWIG_fail;
11005 temp1 = true;
11006 }
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 {
11014 #if wxUSE_UNICODE
11015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11016 #else
11017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11018 #endif
11019 }
11020 {
11021 if (temp1)
11022 delete arg1;
11023 }
11024 return resultobj;
11025 fail:
11026 {
11027 if (temp1)
11028 delete arg1;
11029 }
11030 return NULL;
11031 }
11032
11033
11034 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11035 PyObject *obj;
11036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11037 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11038 return SWIG_Py_Void();
11039 }
11040
11041 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11042 return SWIG_Python_InitShadowInstance(args);
11043 }
11044
11045 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11046 PyObject *resultobj = 0;
11047 wxInternetFSHandler *result = 0 ;
11048
11049 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj = 0;
11065 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11066 wxString *arg2 = 0 ;
11067 bool result;
11068 void *argp1 = 0 ;
11069 int res1 = 0 ;
11070 bool temp2 = false ;
11071 PyObject * obj0 = 0 ;
11072 PyObject * obj1 = 0 ;
11073 char * kwnames[] = {
11074 (char *) "self",(char *) "location", NULL
11075 };
11076
11077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11079 if (!SWIG_IsOK(res1)) {
11080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11081 }
11082 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11083 {
11084 arg2 = wxString_in_helper(obj1);
11085 if (arg2 == NULL) SWIG_fail;
11086 temp2 = true;
11087 }
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11091 wxPyEndAllowThreads(__tstate);
11092 if (PyErr_Occurred()) SWIG_fail;
11093 }
11094 {
11095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11096 }
11097 {
11098 if (temp2)
11099 delete arg2;
11100 }
11101 return resultobj;
11102 fail:
11103 {
11104 if (temp2)
11105 delete arg2;
11106 }
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11112 PyObject *resultobj = 0;
11113 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11114 wxFileSystem *arg2 = 0 ;
11115 wxString *arg3 = 0 ;
11116 wxFSFile *result = 0 ;
11117 void *argp1 = 0 ;
11118 int res1 = 0 ;
11119 void *argp2 = 0 ;
11120 int res2 = 0 ;
11121 bool temp3 = false ;
11122 PyObject * obj0 = 0 ;
11123 PyObject * obj1 = 0 ;
11124 PyObject * obj2 = 0 ;
11125 char * kwnames[] = {
11126 (char *) "self",(char *) "fs",(char *) "location", NULL
11127 };
11128
11129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11131 if (!SWIG_IsOK(res1)) {
11132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11133 }
11134 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11136 if (!SWIG_IsOK(res2)) {
11137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11138 }
11139 if (!argp2) {
11140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11141 }
11142 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11143 {
11144 arg3 = wxString_in_helper(obj2);
11145 if (arg3 == NULL) SWIG_fail;
11146 temp3 = true;
11147 }
11148 {
11149 PyThreadState* __tstate = wxPyBeginAllowThreads();
11150 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11151 wxPyEndAllowThreads(__tstate);
11152 if (PyErr_Occurred()) SWIG_fail;
11153 }
11154 {
11155 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11156 }
11157 {
11158 if (temp3)
11159 delete arg3;
11160 }
11161 return resultobj;
11162 fail:
11163 {
11164 if (temp3)
11165 delete arg3;
11166 }
11167 return NULL;
11168 }
11169
11170
11171 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11172 PyObject *obj;
11173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11174 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11175 return SWIG_Py_Void();
11176 }
11177
11178 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11179 return SWIG_Python_InitShadowInstance(args);
11180 }
11181
11182 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11183 PyObject *resultobj = 0;
11184 wxZipFSHandler *result = 0 ;
11185
11186 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (wxZipFSHandler *)new wxZipFSHandler();
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11194 return resultobj;
11195 fail:
11196 return NULL;
11197 }
11198
11199
11200 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11201 PyObject *resultobj = 0;
11202 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11203 wxString *arg2 = 0 ;
11204 bool result;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 bool temp2 = false ;
11208 PyObject * obj0 = 0 ;
11209 PyObject * obj1 = 0 ;
11210 char * kwnames[] = {
11211 (char *) "self",(char *) "location", NULL
11212 };
11213
11214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11216 if (!SWIG_IsOK(res1)) {
11217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11218 }
11219 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11220 {
11221 arg2 = wxString_in_helper(obj1);
11222 if (arg2 == NULL) SWIG_fail;
11223 temp2 = true;
11224 }
11225 {
11226 PyThreadState* __tstate = wxPyBeginAllowThreads();
11227 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 {
11232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11233 }
11234 {
11235 if (temp2)
11236 delete arg2;
11237 }
11238 return resultobj;
11239 fail:
11240 {
11241 if (temp2)
11242 delete arg2;
11243 }
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj = 0;
11250 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11251 wxFileSystem *arg2 = 0 ;
11252 wxString *arg3 = 0 ;
11253 wxFSFile *result = 0 ;
11254 void *argp1 = 0 ;
11255 int res1 = 0 ;
11256 void *argp2 = 0 ;
11257 int res2 = 0 ;
11258 bool temp3 = false ;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 char * kwnames[] = {
11263 (char *) "self",(char *) "fs",(char *) "location", NULL
11264 };
11265
11266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11268 if (!SWIG_IsOK(res1)) {
11269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11270 }
11271 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11273 if (!SWIG_IsOK(res2)) {
11274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11275 }
11276 if (!argp2) {
11277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11278 }
11279 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11280 {
11281 arg3 = wxString_in_helper(obj2);
11282 if (arg3 == NULL) SWIG_fail;
11283 temp3 = true;
11284 }
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 {
11292 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11293 }
11294 {
11295 if (temp3)
11296 delete arg3;
11297 }
11298 return resultobj;
11299 fail:
11300 {
11301 if (temp3)
11302 delete arg3;
11303 }
11304 return NULL;
11305 }
11306
11307
11308 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11309 PyObject *resultobj = 0;
11310 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11311 wxString *arg2 = 0 ;
11312 int arg3 = (int) 0 ;
11313 wxString result;
11314 void *argp1 = 0 ;
11315 int res1 = 0 ;
11316 bool temp2 = false ;
11317 int val3 ;
11318 int ecode3 = 0 ;
11319 PyObject * obj0 = 0 ;
11320 PyObject * obj1 = 0 ;
11321 PyObject * obj2 = 0 ;
11322 char * kwnames[] = {
11323 (char *) "self",(char *) "spec",(char *) "flags", NULL
11324 };
11325
11326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11328 if (!SWIG_IsOK(res1)) {
11329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11330 }
11331 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11332 {
11333 arg2 = wxString_in_helper(obj1);
11334 if (arg2 == NULL) SWIG_fail;
11335 temp2 = true;
11336 }
11337 if (obj2) {
11338 ecode3 = SWIG_AsVal_int(obj2, &val3);
11339 if (!SWIG_IsOK(ecode3)) {
11340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11341 }
11342 arg3 = static_cast< int >(val3);
11343 }
11344 {
11345 PyThreadState* __tstate = wxPyBeginAllowThreads();
11346 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 {
11351 #if wxUSE_UNICODE
11352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11353 #else
11354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11355 #endif
11356 }
11357 {
11358 if (temp2)
11359 delete arg2;
11360 }
11361 return resultobj;
11362 fail:
11363 {
11364 if (temp2)
11365 delete arg2;
11366 }
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11372 PyObject *resultobj = 0;
11373 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11374 wxString result;
11375 void *argp1 = 0 ;
11376 int res1 = 0 ;
11377 PyObject *swig_obj[1] ;
11378
11379 if (!args) SWIG_fail;
11380 swig_obj[0] = args;
11381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11382 if (!SWIG_IsOK(res1)) {
11383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11384 }
11385 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11386 {
11387 PyThreadState* __tstate = wxPyBeginAllowThreads();
11388 result = (arg1)->FindNext();
11389 wxPyEndAllowThreads(__tstate);
11390 if (PyErr_Occurred()) SWIG_fail;
11391 }
11392 {
11393 #if wxUSE_UNICODE
11394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11395 #else
11396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11397 #endif
11398 }
11399 return resultobj;
11400 fail:
11401 return NULL;
11402 }
11403
11404
11405 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11406 PyObject *obj;
11407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11408 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11409 return SWIG_Py_Void();
11410 }
11411
11412 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11413 return SWIG_Python_InitShadowInstance(args);
11414 }
11415
11416 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj = 0;
11418 wxString *arg1 = 0 ;
11419 wxImage *arg2 = 0 ;
11420 long arg3 ;
11421 bool temp1 = false ;
11422 void *argp2 = 0 ;
11423 int res2 = 0 ;
11424 long val3 ;
11425 int ecode3 = 0 ;
11426 PyObject * obj0 = 0 ;
11427 PyObject * obj1 = 0 ;
11428 PyObject * obj2 = 0 ;
11429 char * kwnames[] = {
11430 (char *) "filename",(char *) "image",(char *) "type", NULL
11431 };
11432
11433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11434 {
11435 arg1 = wxString_in_helper(obj0);
11436 if (arg1 == NULL) SWIG_fail;
11437 temp1 = true;
11438 }
11439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11440 if (!SWIG_IsOK(res2)) {
11441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11442 }
11443 if (!argp2) {
11444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11445 }
11446 arg2 = reinterpret_cast< wxImage * >(argp2);
11447 ecode3 = SWIG_AsVal_long(obj2, &val3);
11448 if (!SWIG_IsOK(ecode3)) {
11449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11450 }
11451 arg3 = static_cast< long >(val3);
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11455 wxPyEndAllowThreads(__tstate);
11456 if (PyErr_Occurred()) SWIG_fail;
11457 }
11458 resultobj = SWIG_Py_Void();
11459 {
11460 if (temp1)
11461 delete arg1;
11462 }
11463 return resultobj;
11464 fail:
11465 {
11466 if (temp1)
11467 delete arg1;
11468 }
11469 return NULL;
11470 }
11471
11472
11473 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj = 0;
11475 wxString *arg1 = 0 ;
11476 wxBitmap *arg2 = 0 ;
11477 long arg3 ;
11478 bool temp1 = false ;
11479 void *argp2 = 0 ;
11480 int res2 = 0 ;
11481 long val3 ;
11482 int ecode3 = 0 ;
11483 PyObject * obj0 = 0 ;
11484 PyObject * obj1 = 0 ;
11485 PyObject * obj2 = 0 ;
11486 char * kwnames[] = {
11487 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11488 };
11489
11490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11491 {
11492 arg1 = wxString_in_helper(obj0);
11493 if (arg1 == NULL) SWIG_fail;
11494 temp1 = true;
11495 }
11496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11497 if (!SWIG_IsOK(res2)) {
11498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11499 }
11500 if (!argp2) {
11501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11502 }
11503 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11504 ecode3 = SWIG_AsVal_long(obj2, &val3);
11505 if (!SWIG_IsOK(ecode3)) {
11506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11507 }
11508 arg3 = static_cast< long >(val3);
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 resultobj = SWIG_Py_Void();
11516 {
11517 if (temp1)
11518 delete arg1;
11519 }
11520 return resultobj;
11521 fail:
11522 {
11523 if (temp1)
11524 delete arg1;
11525 }
11526 return NULL;
11527 }
11528
11529
11530 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj = 0;
11532 wxString *arg1 = 0 ;
11533 PyObject *arg2 = (PyObject *) 0 ;
11534 bool temp1 = false ;
11535 PyObject * obj0 = 0 ;
11536 PyObject * obj1 = 0 ;
11537 char * kwnames[] = {
11538 (char *) "filename",(char *) "data", NULL
11539 };
11540
11541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11542 {
11543 arg1 = wxString_in_helper(obj0);
11544 if (arg1 == NULL) SWIG_fail;
11545 temp1 = true;
11546 }
11547 arg2 = obj1;
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 resultobj = SWIG_Py_Void();
11555 {
11556 if (temp1)
11557 delete arg1;
11558 }
11559 return resultobj;
11560 fail:
11561 {
11562 if (temp1)
11563 delete arg1;
11564 }
11565 return NULL;
11566 }
11567
11568
11569 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11570 PyObject *resultobj = 0;
11571 wxMemoryFSHandler *result = 0 ;
11572
11573 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11574 {
11575 PyThreadState* __tstate = wxPyBeginAllowThreads();
11576 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj = 0;
11589 wxString *arg1 = 0 ;
11590 bool temp1 = false ;
11591 PyObject * obj0 = 0 ;
11592 char * kwnames[] = {
11593 (char *) "filename", NULL
11594 };
11595
11596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11597 {
11598 arg1 = wxString_in_helper(obj0);
11599 if (arg1 == NULL) SWIG_fail;
11600 temp1 = true;
11601 }
11602 {
11603 PyThreadState* __tstate = wxPyBeginAllowThreads();
11604 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 resultobj = SWIG_Py_Void();
11609 {
11610 if (temp1)
11611 delete arg1;
11612 }
11613 return resultobj;
11614 fail:
11615 {
11616 if (temp1)
11617 delete arg1;
11618 }
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11624 PyObject *resultobj = 0;
11625 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11626 wxString *arg2 = 0 ;
11627 bool result;
11628 void *argp1 = 0 ;
11629 int res1 = 0 ;
11630 bool temp2 = false ;
11631 PyObject * obj0 = 0 ;
11632 PyObject * obj1 = 0 ;
11633 char * kwnames[] = {
11634 (char *) "self",(char *) "location", NULL
11635 };
11636
11637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11639 if (!SWIG_IsOK(res1)) {
11640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11641 }
11642 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11643 {
11644 arg2 = wxString_in_helper(obj1);
11645 if (arg2 == NULL) SWIG_fail;
11646 temp2 = true;
11647 }
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 {
11655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11656 }
11657 {
11658 if (temp2)
11659 delete arg2;
11660 }
11661 return resultobj;
11662 fail:
11663 {
11664 if (temp2)
11665 delete arg2;
11666 }
11667 return NULL;
11668 }
11669
11670
11671 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11672 PyObject *resultobj = 0;
11673 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11674 wxFileSystem *arg2 = 0 ;
11675 wxString *arg3 = 0 ;
11676 wxFSFile *result = 0 ;
11677 void *argp1 = 0 ;
11678 int res1 = 0 ;
11679 void *argp2 = 0 ;
11680 int res2 = 0 ;
11681 bool temp3 = false ;
11682 PyObject * obj0 = 0 ;
11683 PyObject * obj1 = 0 ;
11684 PyObject * obj2 = 0 ;
11685 char * kwnames[] = {
11686 (char *) "self",(char *) "fs",(char *) "location", NULL
11687 };
11688
11689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11691 if (!SWIG_IsOK(res1)) {
11692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11693 }
11694 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11696 if (!SWIG_IsOK(res2)) {
11697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11698 }
11699 if (!argp2) {
11700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11701 }
11702 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11703 {
11704 arg3 = wxString_in_helper(obj2);
11705 if (arg3 == NULL) SWIG_fail;
11706 temp3 = true;
11707 }
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11716 }
11717 {
11718 if (temp3)
11719 delete arg3;
11720 }
11721 return resultobj;
11722 fail:
11723 {
11724 if (temp3)
11725 delete arg3;
11726 }
11727 return NULL;
11728 }
11729
11730
11731 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj = 0;
11733 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11734 wxString *arg2 = 0 ;
11735 int arg3 = (int) 0 ;
11736 wxString result;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 bool temp2 = false ;
11740 int val3 ;
11741 int ecode3 = 0 ;
11742 PyObject * obj0 = 0 ;
11743 PyObject * obj1 = 0 ;
11744 PyObject * obj2 = 0 ;
11745 char * kwnames[] = {
11746 (char *) "self",(char *) "spec",(char *) "flags", NULL
11747 };
11748
11749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11751 if (!SWIG_IsOK(res1)) {
11752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11753 }
11754 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11755 {
11756 arg2 = wxString_in_helper(obj1);
11757 if (arg2 == NULL) SWIG_fail;
11758 temp2 = true;
11759 }
11760 if (obj2) {
11761 ecode3 = SWIG_AsVal_int(obj2, &val3);
11762 if (!SWIG_IsOK(ecode3)) {
11763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11764 }
11765 arg3 = static_cast< int >(val3);
11766 }
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11770 wxPyEndAllowThreads(__tstate);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 #if wxUSE_UNICODE
11775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11776 #else
11777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11778 #endif
11779 }
11780 {
11781 if (temp2)
11782 delete arg2;
11783 }
11784 return resultobj;
11785 fail:
11786 {
11787 if (temp2)
11788 delete arg2;
11789 }
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11795 PyObject *resultobj = 0;
11796 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11797 wxString result;
11798 void *argp1 = 0 ;
11799 int res1 = 0 ;
11800 PyObject *swig_obj[1] ;
11801
11802 if (!args) SWIG_fail;
11803 swig_obj[0] = args;
11804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11805 if (!SWIG_IsOK(res1)) {
11806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11807 }
11808 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 result = (arg1)->FindNext();
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 {
11816 #if wxUSE_UNICODE
11817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11818 #else
11819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11820 #endif
11821 }
11822 return resultobj;
11823 fail:
11824 return NULL;
11825 }
11826
11827
11828 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11829 PyObject *obj;
11830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11831 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11832 return SWIG_Py_Void();
11833 }
11834
11835 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 return SWIG_Python_InitShadowInstance(args);
11837 }
11838
11839 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11840 PyObject *resultobj = 0;
11841 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11842 wxString result;
11843 void *argp1 = 0 ;
11844 int res1 = 0 ;
11845 PyObject *swig_obj[1] ;
11846
11847 if (!args) SWIG_fail;
11848 swig_obj[0] = args;
11849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11850 if (!SWIG_IsOK(res1)) {
11851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11852 }
11853 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 result = (arg1)->GetName();
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 {
11861 #if wxUSE_UNICODE
11862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11863 #else
11864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11865 #endif
11866 }
11867 return resultobj;
11868 fail:
11869 return NULL;
11870 }
11871
11872
11873 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11874 PyObject *resultobj = 0;
11875 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11876 wxString result;
11877 void *argp1 = 0 ;
11878 int res1 = 0 ;
11879 PyObject *swig_obj[1] ;
11880
11881 if (!args) SWIG_fail;
11882 swig_obj[0] = args;
11883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11884 if (!SWIG_IsOK(res1)) {
11885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11886 }
11887 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (arg1)->GetExtension();
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 #if wxUSE_UNICODE
11896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11897 #else
11898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11899 #endif
11900 }
11901 return resultobj;
11902 fail:
11903 return NULL;
11904 }
11905
11906
11907 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11908 PyObject *resultobj = 0;
11909 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11910 long result;
11911 void *argp1 = 0 ;
11912 int res1 = 0 ;
11913 PyObject *swig_obj[1] ;
11914
11915 if (!args) SWIG_fail;
11916 swig_obj[0] = args;
11917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11918 if (!SWIG_IsOK(res1)) {
11919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11920 }
11921 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11922 {
11923 PyThreadState* __tstate = wxPyBeginAllowThreads();
11924 result = (long)(arg1)->GetType();
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 resultobj = SWIG_From_long(static_cast< long >(result));
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11936 PyObject *resultobj = 0;
11937 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11938 wxString result;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 PyObject *swig_obj[1] ;
11942
11943 if (!args) SWIG_fail;
11944 swig_obj[0] = args;
11945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11948 }
11949 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (arg1)->GetMimeType();
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 #if wxUSE_UNICODE
11958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11959 #else
11960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11961 #endif
11962 }
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj = 0;
11971 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11972 wxString *arg2 = 0 ;
11973 bool result;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 bool temp2 = false ;
11977 PyObject * obj0 = 0 ;
11978 PyObject * obj1 = 0 ;
11979 char * kwnames[] = {
11980 (char *) "self",(char *) "name", NULL
11981 };
11982
11983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11985 if (!SWIG_IsOK(res1)) {
11986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11987 }
11988 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11989 {
11990 arg2 = wxString_in_helper(obj1);
11991 if (arg2 == NULL) SWIG_fail;
11992 temp2 = true;
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11997 wxPyEndAllowThreads(__tstate);
11998 if (PyErr_Occurred()) SWIG_fail;
11999 }
12000 {
12001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12002 }
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 return resultobj;
12008 fail:
12009 {
12010 if (temp2)
12011 delete arg2;
12012 }
12013 return NULL;
12014 }
12015
12016
12017 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj = 0;
12019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12020 wxInputStream *arg2 = 0 ;
12021 bool result;
12022 void *argp1 = 0 ;
12023 int res1 = 0 ;
12024 wxPyInputStream *temp2 ;
12025 bool created2 ;
12026 PyObject * obj0 = 0 ;
12027 PyObject * obj1 = 0 ;
12028 char * kwnames[] = {
12029 (char *) "self",(char *) "stream", NULL
12030 };
12031
12032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12034 if (!SWIG_IsOK(res1)) {
12035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12036 }
12037 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12038 {
12039 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12040 arg2 = temp2->m_wxis;
12041 created2 = false;
12042 } else {
12043 PyErr_Clear(); // clear the failure of the wxPyConvert above
12044 arg2 = wxPyCBInputStream_create(obj1, false);
12045 if (arg2 == NULL) {
12046 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12047 SWIG_fail;
12048 }
12049 created2 = true;
12050 }
12051 }
12052 {
12053 PyThreadState* __tstate = wxPyBeginAllowThreads();
12054 result = (bool)(arg1)->CanRead(*arg2);
12055 wxPyEndAllowThreads(__tstate);
12056 if (PyErr_Occurred()) SWIG_fail;
12057 }
12058 {
12059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12060 }
12061 {
12062 if (created2) delete arg2;
12063 }
12064 return resultobj;
12065 fail:
12066 {
12067 if (created2) delete arg2;
12068 }
12069 return NULL;
12070 }
12071
12072
12073 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12074 PyObject *resultobj = 0;
12075 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12076 wxString *arg2 = 0 ;
12077 void *argp1 = 0 ;
12078 int res1 = 0 ;
12079 bool temp2 = false ;
12080 PyObject * obj0 = 0 ;
12081 PyObject * obj1 = 0 ;
12082 char * kwnames[] = {
12083 (char *) "self",(char *) "name", NULL
12084 };
12085
12086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12088 if (!SWIG_IsOK(res1)) {
12089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12090 }
12091 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12092 {
12093 arg2 = wxString_in_helper(obj1);
12094 if (arg2 == NULL) SWIG_fail;
12095 temp2 = true;
12096 }
12097 {
12098 PyThreadState* __tstate = wxPyBeginAllowThreads();
12099 (arg1)->SetName((wxString const &)*arg2);
12100 wxPyEndAllowThreads(__tstate);
12101 if (PyErr_Occurred()) SWIG_fail;
12102 }
12103 resultobj = SWIG_Py_Void();
12104 {
12105 if (temp2)
12106 delete arg2;
12107 }
12108 return resultobj;
12109 fail:
12110 {
12111 if (temp2)
12112 delete arg2;
12113 }
12114 return NULL;
12115 }
12116
12117
12118 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12119 PyObject *resultobj = 0;
12120 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12121 wxString *arg2 = 0 ;
12122 void *argp1 = 0 ;
12123 int res1 = 0 ;
12124 bool temp2 = false ;
12125 PyObject * obj0 = 0 ;
12126 PyObject * obj1 = 0 ;
12127 char * kwnames[] = {
12128 (char *) "self",(char *) "extension", NULL
12129 };
12130
12131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12133 if (!SWIG_IsOK(res1)) {
12134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12135 }
12136 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12137 {
12138 arg2 = wxString_in_helper(obj1);
12139 if (arg2 == NULL) SWIG_fail;
12140 temp2 = true;
12141 }
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 (arg1)->SetExtension((wxString const &)*arg2);
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 resultobj = SWIG_Py_Void();
12149 {
12150 if (temp2)
12151 delete arg2;
12152 }
12153 return resultobj;
12154 fail:
12155 {
12156 if (temp2)
12157 delete arg2;
12158 }
12159 return NULL;
12160 }
12161
12162
12163 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj = 0;
12165 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12166 long arg2 ;
12167 void *argp1 = 0 ;
12168 int res1 = 0 ;
12169 long val2 ;
12170 int ecode2 = 0 ;
12171 PyObject * obj0 = 0 ;
12172 PyObject * obj1 = 0 ;
12173 char * kwnames[] = {
12174 (char *) "self",(char *) "type", NULL
12175 };
12176
12177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12179 if (!SWIG_IsOK(res1)) {
12180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12181 }
12182 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12183 ecode2 = SWIG_AsVal_long(obj1, &val2);
12184 if (!SWIG_IsOK(ecode2)) {
12185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12186 }
12187 arg2 = static_cast< long >(val2);
12188 {
12189 PyThreadState* __tstate = wxPyBeginAllowThreads();
12190 (arg1)->SetType(arg2);
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = SWIG_Py_Void();
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12202 PyObject *resultobj = 0;
12203 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12204 wxString *arg2 = 0 ;
12205 void *argp1 = 0 ;
12206 int res1 = 0 ;
12207 bool temp2 = false ;
12208 PyObject * obj0 = 0 ;
12209 PyObject * obj1 = 0 ;
12210 char * kwnames[] = {
12211 (char *) "self",(char *) "mimetype", NULL
12212 };
12213
12214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12218 }
12219 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12220 {
12221 arg2 = wxString_in_helper(obj1);
12222 if (arg2 == NULL) SWIG_fail;
12223 temp2 = true;
12224 }
12225 {
12226 PyThreadState* __tstate = wxPyBeginAllowThreads();
12227 (arg1)->SetMimeType((wxString const &)*arg2);
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 resultobj = SWIG_Py_Void();
12232 {
12233 if (temp2)
12234 delete arg2;
12235 }
12236 return resultobj;
12237 fail:
12238 {
12239 if (temp2)
12240 delete arg2;
12241 }
12242 return NULL;
12243 }
12244
12245
12246 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12247 PyObject *obj;
12248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12249 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12250 return SWIG_Py_Void();
12251 }
12252
12253 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12254 PyObject *resultobj = 0;
12255 wxPyImageHandler *result = 0 ;
12256
12257 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (wxPyImageHandler *)new wxPyImageHandler();
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj = 0;
12273 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12274 PyObject *arg2 = (PyObject *) 0 ;
12275 void *argp1 = 0 ;
12276 int res1 = 0 ;
12277 PyObject * obj0 = 0 ;
12278 PyObject * obj1 = 0 ;
12279 char * kwnames[] = {
12280 (char *) "self",(char *) "self", NULL
12281 };
12282
12283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12285 if (!SWIG_IsOK(res1)) {
12286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12287 }
12288 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12289 arg2 = obj1;
12290 {
12291 PyThreadState* __tstate = wxPyBeginAllowThreads();
12292 (arg1)->_SetSelf(arg2);
12293 wxPyEndAllowThreads(__tstate);
12294 if (PyErr_Occurred()) SWIG_fail;
12295 }
12296 resultobj = SWIG_Py_Void();
12297 return resultobj;
12298 fail:
12299 return NULL;
12300 }
12301
12302
12303 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12304 PyObject *obj;
12305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12306 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12307 return SWIG_Py_Void();
12308 }
12309
12310 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12311 return SWIG_Python_InitShadowInstance(args);
12312 }
12313
12314 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12315 PyObject *resultobj = 0;
12316 wxImageHistogram *result = 0 ;
12317
12318 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (wxImageHistogram *)new wxImageHistogram();
12322 wxPyEndAllowThreads(__tstate);
12323 if (PyErr_Occurred()) SWIG_fail;
12324 }
12325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj = 0;
12334 byte arg1 ;
12335 byte arg2 ;
12336 byte arg3 ;
12337 unsigned long result;
12338 unsigned char val1 ;
12339 int ecode1 = 0 ;
12340 unsigned char val2 ;
12341 int ecode2 = 0 ;
12342 unsigned char val3 ;
12343 int ecode3 = 0 ;
12344 PyObject * obj0 = 0 ;
12345 PyObject * obj1 = 0 ;
12346 PyObject * obj2 = 0 ;
12347 char * kwnames[] = {
12348 (char *) "r",(char *) "g",(char *) "b", NULL
12349 };
12350
12351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12352 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12353 if (!SWIG_IsOK(ecode1)) {
12354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12355 }
12356 arg1 = static_cast< byte >(val1);
12357 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12358 if (!SWIG_IsOK(ecode2)) {
12359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12360 }
12361 arg2 = static_cast< byte >(val2);
12362 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12363 if (!SWIG_IsOK(ecode3)) {
12364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12365 }
12366 arg3 = static_cast< byte >(val3);
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12381 PyObject *resultobj = 0;
12382 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12383 byte *arg2 = (byte *) 0 ;
12384 byte *arg3 = (byte *) 0 ;
12385 byte *arg4 = (byte *) 0 ;
12386 byte arg5 = (byte) 1 ;
12387 byte arg6 = (byte) 0 ;
12388 byte arg7 = (byte) 0 ;
12389 bool result;
12390 void *argp1 = 0 ;
12391 int res1 = 0 ;
12392 byte temp2 ;
12393 int res2 = SWIG_TMPOBJ ;
12394 byte temp3 ;
12395 int res3 = SWIG_TMPOBJ ;
12396 byte temp4 ;
12397 int res4 = SWIG_TMPOBJ ;
12398 unsigned char val5 ;
12399 int ecode5 = 0 ;
12400 unsigned char val6 ;
12401 int ecode6 = 0 ;
12402 unsigned char val7 ;
12403 int ecode7 = 0 ;
12404 PyObject * obj0 = 0 ;
12405 PyObject * obj1 = 0 ;
12406 PyObject * obj2 = 0 ;
12407 PyObject * obj3 = 0 ;
12408 char * kwnames[] = {
12409 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12410 };
12411
12412 arg2 = &temp2;
12413 arg3 = &temp3;
12414 arg4 = &temp4;
12415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12417 if (!SWIG_IsOK(res1)) {
12418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12419 }
12420 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12421 if (obj1) {
12422 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12423 if (!SWIG_IsOK(ecode5)) {
12424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12425 }
12426 arg5 = static_cast< byte >(val5);
12427 }
12428 if (obj2) {
12429 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12430 if (!SWIG_IsOK(ecode6)) {
12431 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12432 }
12433 arg6 = static_cast< byte >(val6);
12434 }
12435 if (obj3) {
12436 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12437 if (!SWIG_IsOK(ecode7)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12439 }
12440 arg7 = static_cast< byte >(val7);
12441 }
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12445 wxPyEndAllowThreads(__tstate);
12446 if (PyErr_Occurred()) SWIG_fail;
12447 }
12448 {
12449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12450 }
12451 if (SWIG_IsTmpObj(res2)) {
12452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12453 } else {
12454 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12456 }
12457 if (SWIG_IsTmpObj(res3)) {
12458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12459 } else {
12460 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12462 }
12463 if (SWIG_IsTmpObj(res4)) {
12464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12465 } else {
12466 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12468 }
12469 return resultobj;
12470 fail:
12471 return NULL;
12472 }
12473
12474
12475 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12476 PyObject *resultobj = 0;
12477 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12478 unsigned long arg2 ;
12479 unsigned long result;
12480 void *argp1 = 0 ;
12481 int res1 = 0 ;
12482 unsigned long val2 ;
12483 int ecode2 = 0 ;
12484 PyObject * obj0 = 0 ;
12485 PyObject * obj1 = 0 ;
12486 char * kwnames[] = {
12487 (char *) "self",(char *) "key", NULL
12488 };
12489
12490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12492 if (!SWIG_IsOK(res1)) {
12493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12494 }
12495 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12496 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12497 if (!SWIG_IsOK(ecode2)) {
12498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12499 }
12500 arg2 = static_cast< unsigned long >(val2);
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12515 PyObject *resultobj = 0;
12516 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12517 byte arg2 ;
12518 byte arg3 ;
12519 byte arg4 ;
12520 unsigned long result;
12521 void *argp1 = 0 ;
12522 int res1 = 0 ;
12523 unsigned char val2 ;
12524 int ecode2 = 0 ;
12525 unsigned char val3 ;
12526 int ecode3 = 0 ;
12527 unsigned char val4 ;
12528 int ecode4 = 0 ;
12529 PyObject * obj0 = 0 ;
12530 PyObject * obj1 = 0 ;
12531 PyObject * obj2 = 0 ;
12532 PyObject * obj3 = 0 ;
12533 char * kwnames[] = {
12534 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12535 };
12536
12537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12539 if (!SWIG_IsOK(res1)) {
12540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12541 }
12542 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12543 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12544 if (!SWIG_IsOK(ecode2)) {
12545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12546 }
12547 arg2 = static_cast< byte >(val2);
12548 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12549 if (!SWIG_IsOK(ecode3)) {
12550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12551 }
12552 arg3 = static_cast< byte >(val3);
12553 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12554 if (!SWIG_IsOK(ecode4)) {
12555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12556 }
12557 arg4 = static_cast< byte >(val4);
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12572 PyObject *resultobj = 0;
12573 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12574 wxColour *arg2 = 0 ;
12575 unsigned long result;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 wxColour temp2 ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 char * kwnames[] = {
12582 (char *) "self",(char *) "colour", NULL
12583 };
12584
12585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12587 if (!SWIG_IsOK(res1)) {
12588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12589 }
12590 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12591 {
12592 arg2 = &temp2;
12593 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12594 }
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12602 return resultobj;
12603 fail:
12604 return NULL;
12605 }
12606
12607
12608 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12609 PyObject *obj;
12610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12611 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12612 return SWIG_Py_Void();
12613 }
12614
12615 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12616 return SWIG_Python_InitShadowInstance(args);
12617 }
12618
12619 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj = 0;
12621 byte arg1 = (byte) 0 ;
12622 byte arg2 = (byte) 0 ;
12623 byte arg3 = (byte) 0 ;
12624 wxImage_RGBValue *result = 0 ;
12625 unsigned char val1 ;
12626 int ecode1 = 0 ;
12627 unsigned char val2 ;
12628 int ecode2 = 0 ;
12629 unsigned char val3 ;
12630 int ecode3 = 0 ;
12631 PyObject * obj0 = 0 ;
12632 PyObject * obj1 = 0 ;
12633 PyObject * obj2 = 0 ;
12634 char * kwnames[] = {
12635 (char *) "r",(char *) "g",(char *) "b", NULL
12636 };
12637
12638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12639 if (obj0) {
12640 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12641 if (!SWIG_IsOK(ecode1)) {
12642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12643 }
12644 arg1 = static_cast< byte >(val1);
12645 }
12646 if (obj1) {
12647 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12648 if (!SWIG_IsOK(ecode2)) {
12649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12650 }
12651 arg2 = static_cast< byte >(val2);
12652 }
12653 if (obj2) {
12654 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12655 if (!SWIG_IsOK(ecode3)) {
12656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12657 }
12658 arg3 = static_cast< byte >(val3);
12659 }
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12674 PyObject *resultobj = 0;
12675 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12676 byte arg2 ;
12677 void *argp1 = 0 ;
12678 int res1 = 0 ;
12679 unsigned char val2 ;
12680 int ecode2 = 0 ;
12681 PyObject *swig_obj[2] ;
12682
12683 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12685 if (!SWIG_IsOK(res1)) {
12686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12687 }
12688 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12689 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12690 if (!SWIG_IsOK(ecode2)) {
12691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12692 }
12693 arg2 = static_cast< byte >(val2);
12694 if (arg1) (arg1)->red = arg2;
12695
12696 resultobj = SWIG_Py_Void();
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12704 PyObject *resultobj = 0;
12705 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12706 byte result;
12707 void *argp1 = 0 ;
12708 int res1 = 0 ;
12709 PyObject *swig_obj[1] ;
12710
12711 if (!args) SWIG_fail;
12712 swig_obj[0] = args;
12713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12714 if (!SWIG_IsOK(res1)) {
12715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12716 }
12717 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12718 result = (byte) ((arg1)->red);
12719 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12720 return resultobj;
12721 fail:
12722 return NULL;
12723 }
12724
12725
12726 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12727 PyObject *resultobj = 0;
12728 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12729 byte arg2 ;
12730 void *argp1 = 0 ;
12731 int res1 = 0 ;
12732 unsigned char val2 ;
12733 int ecode2 = 0 ;
12734 PyObject *swig_obj[2] ;
12735
12736 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12738 if (!SWIG_IsOK(res1)) {
12739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12740 }
12741 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12742 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12743 if (!SWIG_IsOK(ecode2)) {
12744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12745 }
12746 arg2 = static_cast< byte >(val2);
12747 if (arg1) (arg1)->green = arg2;
12748
12749 resultobj = SWIG_Py_Void();
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12757 PyObject *resultobj = 0;
12758 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12759 byte result;
12760 void *argp1 = 0 ;
12761 int res1 = 0 ;
12762 PyObject *swig_obj[1] ;
12763
12764 if (!args) SWIG_fail;
12765 swig_obj[0] = args;
12766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12767 if (!SWIG_IsOK(res1)) {
12768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12769 }
12770 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12771 result = (byte) ((arg1)->green);
12772 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12780 PyObject *resultobj = 0;
12781 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12782 byte arg2 ;
12783 void *argp1 = 0 ;
12784 int res1 = 0 ;
12785 unsigned char val2 ;
12786 int ecode2 = 0 ;
12787 PyObject *swig_obj[2] ;
12788
12789 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12791 if (!SWIG_IsOK(res1)) {
12792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12793 }
12794 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12795 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12796 if (!SWIG_IsOK(ecode2)) {
12797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12798 }
12799 arg2 = static_cast< byte >(val2);
12800 if (arg1) (arg1)->blue = arg2;
12801
12802 resultobj = SWIG_Py_Void();
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12810 PyObject *resultobj = 0;
12811 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12812 byte result;
12813 void *argp1 = 0 ;
12814 int res1 = 0 ;
12815 PyObject *swig_obj[1] ;
12816
12817 if (!args) SWIG_fail;
12818 swig_obj[0] = args;
12819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12820 if (!SWIG_IsOK(res1)) {
12821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12822 }
12823 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12824 result = (byte) ((arg1)->blue);
12825 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12833 PyObject *obj;
12834 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12835 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12836 return SWIG_Py_Void();
12837 }
12838
12839 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 return SWIG_Python_InitShadowInstance(args);
12841 }
12842
12843 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12844 PyObject *resultobj = 0;
12845 double arg1 = (double) 0.0 ;
12846 double arg2 = (double) 0.0 ;
12847 double arg3 = (double) 0.0 ;
12848 wxImage_HSVValue *result = 0 ;
12849 double val1 ;
12850 int ecode1 = 0 ;
12851 double val2 ;
12852 int ecode2 = 0 ;
12853 double val3 ;
12854 int ecode3 = 0 ;
12855 PyObject * obj0 = 0 ;
12856 PyObject * obj1 = 0 ;
12857 PyObject * obj2 = 0 ;
12858 char * kwnames[] = {
12859 (char *) "h",(char *) "s",(char *) "v", NULL
12860 };
12861
12862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12863 if (obj0) {
12864 ecode1 = SWIG_AsVal_double(obj0, &val1);
12865 if (!SWIG_IsOK(ecode1)) {
12866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12867 }
12868 arg1 = static_cast< double >(val1);
12869 }
12870 if (obj1) {
12871 ecode2 = SWIG_AsVal_double(obj1, &val2);
12872 if (!SWIG_IsOK(ecode2)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12874 }
12875 arg2 = static_cast< double >(val2);
12876 }
12877 if (obj2) {
12878 ecode3 = SWIG_AsVal_double(obj2, &val3);
12879 if (!SWIG_IsOK(ecode3)) {
12880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12881 }
12882 arg3 = static_cast< double >(val3);
12883 }
12884 {
12885 PyThreadState* __tstate = wxPyBeginAllowThreads();
12886 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12891 return resultobj;
12892 fail:
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12898 PyObject *resultobj = 0;
12899 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12900 double arg2 ;
12901 void *argp1 = 0 ;
12902 int res1 = 0 ;
12903 double val2 ;
12904 int ecode2 = 0 ;
12905 PyObject *swig_obj[2] ;
12906
12907 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12909 if (!SWIG_IsOK(res1)) {
12910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12911 }
12912 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12913 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12914 if (!SWIG_IsOK(ecode2)) {
12915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12916 }
12917 arg2 = static_cast< double >(val2);
12918 if (arg1) (arg1)->hue = arg2;
12919
12920 resultobj = SWIG_Py_Void();
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 PyObject *resultobj = 0;
12929 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12930 double result;
12931 void *argp1 = 0 ;
12932 int res1 = 0 ;
12933 PyObject *swig_obj[1] ;
12934
12935 if (!args) SWIG_fail;
12936 swig_obj[0] = args;
12937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12938 if (!SWIG_IsOK(res1)) {
12939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12940 }
12941 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12942 result = (double) ((arg1)->hue);
12943 resultobj = SWIG_From_double(static_cast< double >(result));
12944 return resultobj;
12945 fail:
12946 return NULL;
12947 }
12948
12949
12950 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12951 PyObject *resultobj = 0;
12952 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12953 double arg2 ;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 double val2 ;
12957 int ecode2 = 0 ;
12958 PyObject *swig_obj[2] ;
12959
12960 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12962 if (!SWIG_IsOK(res1)) {
12963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12964 }
12965 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12966 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12967 if (!SWIG_IsOK(ecode2)) {
12968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12969 }
12970 arg2 = static_cast< double >(val2);
12971 if (arg1) (arg1)->saturation = arg2;
12972
12973 resultobj = SWIG_Py_Void();
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *resultobj = 0;
12982 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12983 double result;
12984 void *argp1 = 0 ;
12985 int res1 = 0 ;
12986 PyObject *swig_obj[1] ;
12987
12988 if (!args) SWIG_fail;
12989 swig_obj[0] = args;
12990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12991 if (!SWIG_IsOK(res1)) {
12992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12993 }
12994 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12995 result = (double) ((arg1)->saturation);
12996 resultobj = SWIG_From_double(static_cast< double >(result));
12997 return resultobj;
12998 fail:
12999 return NULL;
13000 }
13001
13002
13003 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13004 PyObject *resultobj = 0;
13005 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13006 double arg2 ;
13007 void *argp1 = 0 ;
13008 int res1 = 0 ;
13009 double val2 ;
13010 int ecode2 = 0 ;
13011 PyObject *swig_obj[2] ;
13012
13013 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13015 if (!SWIG_IsOK(res1)) {
13016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13017 }
13018 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13019 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13020 if (!SWIG_IsOK(ecode2)) {
13021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13022 }
13023 arg2 = static_cast< double >(val2);
13024 if (arg1) (arg1)->value = arg2;
13025
13026 resultobj = SWIG_Py_Void();
13027 return resultobj;
13028 fail:
13029 return NULL;
13030 }
13031
13032
13033 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13034 PyObject *resultobj = 0;
13035 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13036 double result;
13037 void *argp1 = 0 ;
13038 int res1 = 0 ;
13039 PyObject *swig_obj[1] ;
13040
13041 if (!args) SWIG_fail;
13042 swig_obj[0] = args;
13043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13044 if (!SWIG_IsOK(res1)) {
13045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13046 }
13047 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13048 result = (double) ((arg1)->value);
13049 resultobj = SWIG_From_double(static_cast< double >(result));
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *obj;
13058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13059 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13060 return SWIG_Py_Void();
13061 }
13062
13063 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13064 return SWIG_Python_InitShadowInstance(args);
13065 }
13066
13067 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj = 0;
13069 wxString *arg1 = 0 ;
13070 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13071 int arg3 = (int) -1 ;
13072 wxImage *result = 0 ;
13073 bool temp1 = false ;
13074 long val2 ;
13075 int ecode2 = 0 ;
13076 int val3 ;
13077 int ecode3 = 0 ;
13078 PyObject * obj0 = 0 ;
13079 PyObject * obj1 = 0 ;
13080 PyObject * obj2 = 0 ;
13081 char * kwnames[] = {
13082 (char *) "name",(char *) "type",(char *) "index", NULL
13083 };
13084
13085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13086 {
13087 arg1 = wxString_in_helper(obj0);
13088 if (arg1 == NULL) SWIG_fail;
13089 temp1 = true;
13090 }
13091 if (obj1) {
13092 ecode2 = SWIG_AsVal_long(obj1, &val2);
13093 if (!SWIG_IsOK(ecode2)) {
13094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13095 }
13096 arg2 = static_cast< long >(val2);
13097 }
13098 if (obj2) {
13099 ecode3 = SWIG_AsVal_int(obj2, &val3);
13100 if (!SWIG_IsOK(ecode3)) {
13101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13102 }
13103 arg3 = static_cast< int >(val3);
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13112 {
13113 if (temp1)
13114 delete arg1;
13115 }
13116 return resultobj;
13117 fail:
13118 {
13119 if (temp1)
13120 delete arg1;
13121 }
13122 return NULL;
13123 }
13124
13125
13126 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13127 PyObject *resultobj = 0;
13128 wxImage *arg1 = (wxImage *) 0 ;
13129 void *argp1 = 0 ;
13130 int res1 = 0 ;
13131 PyObject *swig_obj[1] ;
13132
13133 if (!args) SWIG_fail;
13134 swig_obj[0] = args;
13135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13136 if (!SWIG_IsOK(res1)) {
13137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13138 }
13139 arg1 = reinterpret_cast< wxImage * >(argp1);
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 delete arg1;
13143
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 resultobj = SWIG_Py_Void();
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj = 0;
13156 wxString *arg1 = 0 ;
13157 wxString *arg2 = 0 ;
13158 int arg3 = (int) -1 ;
13159 wxImage *result = 0 ;
13160 bool temp1 = false ;
13161 bool temp2 = false ;
13162 int val3 ;
13163 int ecode3 = 0 ;
13164 PyObject * obj0 = 0 ;
13165 PyObject * obj1 = 0 ;
13166 PyObject * obj2 = 0 ;
13167 char * kwnames[] = {
13168 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13169 };
13170
13171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13172 {
13173 arg1 = wxString_in_helper(obj0);
13174 if (arg1 == NULL) SWIG_fail;
13175 temp1 = true;
13176 }
13177 {
13178 arg2 = wxString_in_helper(obj1);
13179 if (arg2 == NULL) SWIG_fail;
13180 temp2 = true;
13181 }
13182 if (obj2) {
13183 ecode3 = SWIG_AsVal_int(obj2, &val3);
13184 if (!SWIG_IsOK(ecode3)) {
13185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13186 }
13187 arg3 = static_cast< int >(val3);
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13196 {
13197 if (temp1)
13198 delete arg1;
13199 }
13200 {
13201 if (temp2)
13202 delete arg2;
13203 }
13204 return resultobj;
13205 fail:
13206 {
13207 if (temp1)
13208 delete arg1;
13209 }
13210 {
13211 if (temp2)
13212 delete arg2;
13213 }
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj = 0;
13220 wxInputStream *arg1 = 0 ;
13221 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13222 int arg3 = (int) -1 ;
13223 wxImage *result = 0 ;
13224 wxPyInputStream *temp1 ;
13225 bool created1 ;
13226 long val2 ;
13227 int ecode2 = 0 ;
13228 int val3 ;
13229 int ecode3 = 0 ;
13230 PyObject * obj0 = 0 ;
13231 PyObject * obj1 = 0 ;
13232 PyObject * obj2 = 0 ;
13233 char * kwnames[] = {
13234 (char *) "stream",(char *) "type",(char *) "index", NULL
13235 };
13236
13237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13238 {
13239 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13240 arg1 = temp1->m_wxis;
13241 created1 = false;
13242 } else {
13243 PyErr_Clear(); // clear the failure of the wxPyConvert above
13244 arg1 = wxPyCBInputStream_create(obj0, false);
13245 if (arg1 == NULL) {
13246 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13247 SWIG_fail;
13248 }
13249 created1 = true;
13250 }
13251 }
13252 if (obj1) {
13253 ecode2 = SWIG_AsVal_long(obj1, &val2);
13254 if (!SWIG_IsOK(ecode2)) {
13255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13256 }
13257 arg2 = static_cast< long >(val2);
13258 }
13259 if (obj2) {
13260 ecode3 = SWIG_AsVal_int(obj2, &val3);
13261 if (!SWIG_IsOK(ecode3)) {
13262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13263 }
13264 arg3 = static_cast< int >(val3);
13265 }
13266 {
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13273 {
13274 if (created1) delete arg1;
13275 }
13276 return resultobj;
13277 fail:
13278 {
13279 if (created1) delete arg1;
13280 }
13281 return NULL;
13282 }
13283
13284
13285 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj = 0;
13287 wxInputStream *arg1 = 0 ;
13288 wxString *arg2 = 0 ;
13289 int arg3 = (int) -1 ;
13290 wxImage *result = 0 ;
13291 wxPyInputStream *temp1 ;
13292 bool created1 ;
13293 bool temp2 = false ;
13294 int val3 ;
13295 int ecode3 = 0 ;
13296 PyObject * obj0 = 0 ;
13297 PyObject * obj1 = 0 ;
13298 PyObject * obj2 = 0 ;
13299 char * kwnames[] = {
13300 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13301 };
13302
13303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13304 {
13305 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13306 arg1 = temp1->m_wxis;
13307 created1 = false;
13308 } else {
13309 PyErr_Clear(); // clear the failure of the wxPyConvert above
13310 arg1 = wxPyCBInputStream_create(obj0, false);
13311 if (arg1 == NULL) {
13312 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13313 SWIG_fail;
13314 }
13315 created1 = true;
13316 }
13317 }
13318 {
13319 arg2 = wxString_in_helper(obj1);
13320 if (arg2 == NULL) SWIG_fail;
13321 temp2 = true;
13322 }
13323 if (obj2) {
13324 ecode3 = SWIG_AsVal_int(obj2, &val3);
13325 if (!SWIG_IsOK(ecode3)) {
13326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13327 }
13328 arg3 = static_cast< int >(val3);
13329 }
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13337 {
13338 if (created1) delete arg1;
13339 }
13340 {
13341 if (temp2)
13342 delete arg2;
13343 }
13344 return resultobj;
13345 fail:
13346 {
13347 if (created1) delete arg1;
13348 }
13349 {
13350 if (temp2)
13351 delete arg2;
13352 }
13353 return NULL;
13354 }
13355
13356
13357 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13358 PyObject *resultobj = 0;
13359 int arg1 = (int) 0 ;
13360 int arg2 = (int) 0 ;
13361 bool arg3 = (bool) true ;
13362 wxImage *result = 0 ;
13363 int val1 ;
13364 int ecode1 = 0 ;
13365 int val2 ;
13366 int ecode2 = 0 ;
13367 bool val3 ;
13368 int ecode3 = 0 ;
13369 PyObject * obj0 = 0 ;
13370 PyObject * obj1 = 0 ;
13371 PyObject * obj2 = 0 ;
13372 char * kwnames[] = {
13373 (char *) "width",(char *) "height",(char *) "clear", NULL
13374 };
13375
13376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13377 if (obj0) {
13378 ecode1 = SWIG_AsVal_int(obj0, &val1);
13379 if (!SWIG_IsOK(ecode1)) {
13380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13381 }
13382 arg1 = static_cast< int >(val1);
13383 }
13384 if (obj1) {
13385 ecode2 = SWIG_AsVal_int(obj1, &val2);
13386 if (!SWIG_IsOK(ecode2)) {
13387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13388 }
13389 arg2 = static_cast< int >(val2);
13390 }
13391 if (obj2) {
13392 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13393 if (!SWIG_IsOK(ecode3)) {
13394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13395 }
13396 arg3 = static_cast< bool >(val3);
13397 }
13398 {
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13412 PyObject *resultobj = 0;
13413 wxBitmap *arg1 = 0 ;
13414 wxImage *result = 0 ;
13415 void *argp1 = 0 ;
13416 int res1 = 0 ;
13417 PyObject * obj0 = 0 ;
13418 char * kwnames[] = {
13419 (char *) "bitmap", NULL
13420 };
13421
13422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13423 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13424 if (!SWIG_IsOK(res1)) {
13425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13426 }
13427 if (!argp1) {
13428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13429 }
13430 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13431 {
13432 if (!wxPyCheckForApp()) SWIG_fail;
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13439 return resultobj;
13440 fail:
13441 return NULL;
13442 }
13443
13444
13445 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13446 PyObject *resultobj = 0;
13447 int arg1 ;
13448 int arg2 ;
13449 buffer arg3 ;
13450 int arg4 ;
13451 wxImage *result = 0 ;
13452 int val1 ;
13453 int ecode1 = 0 ;
13454 int val2 ;
13455 int ecode2 = 0 ;
13456 Py_ssize_t temp3 ;
13457 PyObject * obj0 = 0 ;
13458 PyObject * obj1 = 0 ;
13459 PyObject * obj2 = 0 ;
13460 char * kwnames[] = {
13461 (char *) "width",(char *) "height",(char *) "data", NULL
13462 };
13463
13464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13465 ecode1 = SWIG_AsVal_int(obj0, &val1);
13466 if (!SWIG_IsOK(ecode1)) {
13467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13468 }
13469 arg1 = static_cast< int >(val1);
13470 ecode2 = SWIG_AsVal_int(obj1, &val2);
13471 if (!SWIG_IsOK(ecode2)) {
13472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13473 }
13474 arg2 = static_cast< int >(val2);
13475 {
13476 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13477 arg4 = (int)temp3;
13478 }
13479 {
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13482 wxPyEndAllowThreads(__tstate);
13483 if (PyErr_Occurred()) SWIG_fail;
13484 }
13485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13486 return resultobj;
13487 fail:
13488 return NULL;
13489 }
13490
13491
13492 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13493 PyObject *resultobj = 0;
13494 int arg1 ;
13495 int arg2 ;
13496 buffer arg3 ;
13497 int arg4 ;
13498 buffer arg5 ;
13499 int arg6 ;
13500 wxImage *result = 0 ;
13501 int val1 ;
13502 int ecode1 = 0 ;
13503 int val2 ;
13504 int ecode2 = 0 ;
13505 Py_ssize_t temp3 ;
13506 Py_ssize_t temp5 ;
13507 PyObject * obj0 = 0 ;
13508 PyObject * obj1 = 0 ;
13509 PyObject * obj2 = 0 ;
13510 PyObject * obj3 = 0 ;
13511 char * kwnames[] = {
13512 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13513 };
13514
13515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13516 ecode1 = SWIG_AsVal_int(obj0, &val1);
13517 if (!SWIG_IsOK(ecode1)) {
13518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13519 }
13520 arg1 = static_cast< int >(val1);
13521 ecode2 = SWIG_AsVal_int(obj1, &val2);
13522 if (!SWIG_IsOK(ecode2)) {
13523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13524 }
13525 arg2 = static_cast< int >(val2);
13526 {
13527 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13528 arg4 = (int)temp3;
13529 }
13530 {
13531 if (obj3 != Py_None) {
13532 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13533 arg6 = (int)temp5;
13534 }
13535 }
13536 {
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13539 wxPyEndAllowThreads(__tstate);
13540 if (PyErr_Occurred()) SWIG_fail;
13541 }
13542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13543 return resultobj;
13544 fail:
13545 return NULL;
13546 }
13547
13548
13549 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13550 PyObject *resultobj = 0;
13551 wxImage *arg1 = (wxImage *) 0 ;
13552 int arg2 ;
13553 int arg3 ;
13554 bool arg4 = (bool) true ;
13555 void *argp1 = 0 ;
13556 int res1 = 0 ;
13557 int val2 ;
13558 int ecode2 = 0 ;
13559 int val3 ;
13560 int ecode3 = 0 ;
13561 bool val4 ;
13562 int ecode4 = 0 ;
13563 PyObject * obj0 = 0 ;
13564 PyObject * obj1 = 0 ;
13565 PyObject * obj2 = 0 ;
13566 PyObject * obj3 = 0 ;
13567 char * kwnames[] = {
13568 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13569 };
13570
13571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13575 }
13576 arg1 = reinterpret_cast< wxImage * >(argp1);
13577 ecode2 = SWIG_AsVal_int(obj1, &val2);
13578 if (!SWIG_IsOK(ecode2)) {
13579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13580 }
13581 arg2 = static_cast< int >(val2);
13582 ecode3 = SWIG_AsVal_int(obj2, &val3);
13583 if (!SWIG_IsOK(ecode3)) {
13584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13585 }
13586 arg3 = static_cast< int >(val3);
13587 if (obj3) {
13588 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13589 if (!SWIG_IsOK(ecode4)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13591 }
13592 arg4 = static_cast< bool >(val4);
13593 }
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 (arg1)->Create(arg2,arg3,arg4);
13597 wxPyEndAllowThreads(__tstate);
13598 if (PyErr_Occurred()) SWIG_fail;
13599 }
13600 resultobj = SWIG_Py_Void();
13601 return resultobj;
13602 fail:
13603 return NULL;
13604 }
13605
13606
13607 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13608 PyObject *resultobj = 0;
13609 wxImage *arg1 = (wxImage *) 0 ;
13610 void *argp1 = 0 ;
13611 int res1 = 0 ;
13612 PyObject *swig_obj[1] ;
13613
13614 if (!args) SWIG_fail;
13615 swig_obj[0] = args;
13616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13617 if (!SWIG_IsOK(res1)) {
13618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13619 }
13620 arg1 = reinterpret_cast< wxImage * >(argp1);
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 (arg1)->Destroy();
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 resultobj = SWIG_Py_Void();
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj = 0;
13636 wxImage *arg1 = (wxImage *) 0 ;
13637 int arg2 ;
13638 int arg3 ;
13639 SwigValueWrapper<wxImage > result;
13640 void *argp1 = 0 ;
13641 int res1 = 0 ;
13642 int val2 ;
13643 int ecode2 = 0 ;
13644 int val3 ;
13645 int ecode3 = 0 ;
13646 PyObject * obj0 = 0 ;
13647 PyObject * obj1 = 0 ;
13648 PyObject * obj2 = 0 ;
13649 char * kwnames[] = {
13650 (char *) "self",(char *) "width",(char *) "height", NULL
13651 };
13652
13653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13655 if (!SWIG_IsOK(res1)) {
13656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13657 }
13658 arg1 = reinterpret_cast< wxImage * >(argp1);
13659 ecode2 = SWIG_AsVal_int(obj1, &val2);
13660 if (!SWIG_IsOK(ecode2)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13662 }
13663 arg2 = static_cast< int >(val2);
13664 ecode3 = SWIG_AsVal_int(obj2, &val3);
13665 if (!SWIG_IsOK(ecode3)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13667 }
13668 arg3 = static_cast< int >(val3);
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 result = (arg1)->Scale(arg2,arg3);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 wxImage *arg1 = (wxImage *) 0 ;
13685 int arg2 ;
13686 int arg3 ;
13687 SwigValueWrapper<wxImage > result;
13688 void *argp1 = 0 ;
13689 int res1 = 0 ;
13690 int val2 ;
13691 int ecode2 = 0 ;
13692 int val3 ;
13693 int ecode3 = 0 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 ecode2 = SWIG_AsVal_int(obj1, &val2);
13708 if (!SWIG_IsOK(ecode2)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13710 }
13711 arg2 = static_cast< int >(val2);
13712 ecode3 = SWIG_AsVal_int(obj2, &val3);
13713 if (!SWIG_IsOK(ecode3)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13715 }
13716 arg3 = static_cast< int >(val3);
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13720 wxPyEndAllowThreads(__tstate);
13721 if (PyErr_Occurred()) SWIG_fail;
13722 }
13723 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13724 return resultobj;
13725 fail:
13726 return NULL;
13727 }
13728
13729
13730 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13731 PyObject *resultobj = 0;
13732 wxImage *arg1 = (wxImage *) 0 ;
13733 int arg2 ;
13734 int arg3 ;
13735 wxImage *result = 0 ;
13736 void *argp1 = 0 ;
13737 int res1 = 0 ;
13738 int val2 ;
13739 int ecode2 = 0 ;
13740 int val3 ;
13741 int ecode3 = 0 ;
13742 PyObject * obj0 = 0 ;
13743 PyObject * obj1 = 0 ;
13744 PyObject * obj2 = 0 ;
13745 char * kwnames[] = {
13746 (char *) "self",(char *) "width",(char *) "height", NULL
13747 };
13748
13749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13751 if (!SWIG_IsOK(res1)) {
13752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13753 }
13754 arg1 = reinterpret_cast< wxImage * >(argp1);
13755 ecode2 = SWIG_AsVal_int(obj1, &val2);
13756 if (!SWIG_IsOK(ecode2)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13758 }
13759 arg2 = static_cast< int >(val2);
13760 ecode3 = SWIG_AsVal_int(obj2, &val3);
13761 if (!SWIG_IsOK(ecode3)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13763 }
13764 arg3 = static_cast< int >(val3);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 {
13768 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13769 result = (wxImage *) &_result_ref;
13770 }
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13775 return resultobj;
13776 fail:
13777 return NULL;
13778 }
13779
13780
13781 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj = 0;
13783 wxImage *arg1 = (wxImage *) 0 ;
13784 wxSize *arg2 = 0 ;
13785 wxPoint *arg3 = 0 ;
13786 int arg4 = (int) -1 ;
13787 int arg5 = (int) -1 ;
13788 int arg6 = (int) -1 ;
13789 wxImage *result = 0 ;
13790 void *argp1 = 0 ;
13791 int res1 = 0 ;
13792 wxSize temp2 ;
13793 wxPoint temp3 ;
13794 int val4 ;
13795 int ecode4 = 0 ;
13796 int val5 ;
13797 int ecode5 = 0 ;
13798 int val6 ;
13799 int ecode6 = 0 ;
13800 PyObject * obj0 = 0 ;
13801 PyObject * obj1 = 0 ;
13802 PyObject * obj2 = 0 ;
13803 PyObject * obj3 = 0 ;
13804 PyObject * obj4 = 0 ;
13805 PyObject * obj5 = 0 ;
13806 char * kwnames[] = {
13807 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13808 };
13809
13810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13812 if (!SWIG_IsOK(res1)) {
13813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13814 }
13815 arg1 = reinterpret_cast< wxImage * >(argp1);
13816 {
13817 arg2 = &temp2;
13818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13819 }
13820 {
13821 arg3 = &temp3;
13822 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13823 }
13824 if (obj3) {
13825 ecode4 = SWIG_AsVal_int(obj3, &val4);
13826 if (!SWIG_IsOK(ecode4)) {
13827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13828 }
13829 arg4 = static_cast< int >(val4);
13830 }
13831 if (obj4) {
13832 ecode5 = SWIG_AsVal_int(obj4, &val5);
13833 if (!SWIG_IsOK(ecode5)) {
13834 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13835 }
13836 arg5 = static_cast< int >(val5);
13837 }
13838 if (obj5) {
13839 ecode6 = SWIG_AsVal_int(obj5, &val6);
13840 if (!SWIG_IsOK(ecode6)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13842 }
13843 arg6 = static_cast< int >(val6);
13844 }
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 {
13848 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13849 result = (wxImage *) &_result_ref;
13850 }
13851 wxPyEndAllowThreads(__tstate);
13852 if (PyErr_Occurred()) SWIG_fail;
13853 }
13854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13855 return resultobj;
13856 fail:
13857 return NULL;
13858 }
13859
13860
13861 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13862 PyObject *resultobj = 0;
13863 wxImage *arg1 = (wxImage *) 0 ;
13864 int arg2 ;
13865 int arg3 ;
13866 byte arg4 ;
13867 byte arg5 ;
13868 byte arg6 ;
13869 void *argp1 = 0 ;
13870 int res1 = 0 ;
13871 int val2 ;
13872 int ecode2 = 0 ;
13873 int val3 ;
13874 int ecode3 = 0 ;
13875 unsigned char val4 ;
13876 int ecode4 = 0 ;
13877 unsigned char val5 ;
13878 int ecode5 = 0 ;
13879 unsigned char val6 ;
13880 int ecode6 = 0 ;
13881 PyObject * obj0 = 0 ;
13882 PyObject * obj1 = 0 ;
13883 PyObject * obj2 = 0 ;
13884 PyObject * obj3 = 0 ;
13885 PyObject * obj4 = 0 ;
13886 PyObject * obj5 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13893 if (!SWIG_IsOK(res1)) {
13894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13895 }
13896 arg1 = reinterpret_cast< wxImage * >(argp1);
13897 ecode2 = SWIG_AsVal_int(obj1, &val2);
13898 if (!SWIG_IsOK(ecode2)) {
13899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13900 }
13901 arg2 = static_cast< int >(val2);
13902 ecode3 = SWIG_AsVal_int(obj2, &val3);
13903 if (!SWIG_IsOK(ecode3)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13905 }
13906 arg3 = static_cast< int >(val3);
13907 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13908 if (!SWIG_IsOK(ecode4)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13910 }
13911 arg4 = static_cast< byte >(val4);
13912 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13913 if (!SWIG_IsOK(ecode5)) {
13914 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13915 }
13916 arg5 = static_cast< byte >(val5);
13917 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13918 if (!SWIG_IsOK(ecode6)) {
13919 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13920 }
13921 arg6 = static_cast< byte >(val6);
13922 {
13923 PyThreadState* __tstate = wxPyBeginAllowThreads();
13924 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13925 wxPyEndAllowThreads(__tstate);
13926 if (PyErr_Occurred()) SWIG_fail;
13927 }
13928 resultobj = SWIG_Py_Void();
13929 return resultobj;
13930 fail:
13931 return NULL;
13932 }
13933
13934
13935 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13936 PyObject *resultobj = 0;
13937 wxImage *arg1 = (wxImage *) 0 ;
13938 wxRect *arg2 = 0 ;
13939 byte arg3 ;
13940 byte arg4 ;
13941 byte arg5 ;
13942 void *argp1 = 0 ;
13943 int res1 = 0 ;
13944 wxRect temp2 ;
13945 unsigned char val3 ;
13946 int ecode3 = 0 ;
13947 unsigned char val4 ;
13948 int ecode4 = 0 ;
13949 unsigned char val5 ;
13950 int ecode5 = 0 ;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 PyObject * obj2 = 0 ;
13954 PyObject * obj3 = 0 ;
13955 PyObject * obj4 = 0 ;
13956 char * kwnames[] = {
13957 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13958 };
13959
13960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13962 if (!SWIG_IsOK(res1)) {
13963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13964 }
13965 arg1 = reinterpret_cast< wxImage * >(argp1);
13966 {
13967 arg2 = &temp2;
13968 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13969 }
13970 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13971 if (!SWIG_IsOK(ecode3)) {
13972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13973 }
13974 arg3 = static_cast< byte >(val3);
13975 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13976 if (!SWIG_IsOK(ecode4)) {
13977 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13978 }
13979 arg4 = static_cast< byte >(val4);
13980 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13981 if (!SWIG_IsOK(ecode5)) {
13982 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13983 }
13984 arg5 = static_cast< byte >(val5);
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 resultobj = SWIG_Py_Void();
13992 return resultobj;
13993 fail:
13994 return NULL;
13995 }
13996
13997
13998 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj = 0;
14000 wxImage *arg1 = (wxImage *) 0 ;
14001 int arg2 ;
14002 int arg3 ;
14003 byte result;
14004 void *argp1 = 0 ;
14005 int res1 = 0 ;
14006 int val2 ;
14007 int ecode2 = 0 ;
14008 int val3 ;
14009 int ecode3 = 0 ;
14010 PyObject * obj0 = 0 ;
14011 PyObject * obj1 = 0 ;
14012 PyObject * obj2 = 0 ;
14013 char * kwnames[] = {
14014 (char *) "self",(char *) "x",(char *) "y", NULL
14015 };
14016
14017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14019 if (!SWIG_IsOK(res1)) {
14020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14021 }
14022 arg1 = reinterpret_cast< wxImage * >(argp1);
14023 ecode2 = SWIG_AsVal_int(obj1, &val2);
14024 if (!SWIG_IsOK(ecode2)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14026 }
14027 arg2 = static_cast< int >(val2);
14028 ecode3 = SWIG_AsVal_int(obj2, &val3);
14029 if (!SWIG_IsOK(ecode3)) {
14030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14031 }
14032 arg3 = static_cast< int >(val3);
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 result = (byte)(arg1)->GetRed(arg2,arg3);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14040 return resultobj;
14041 fail:
14042 return NULL;
14043 }
14044
14045
14046 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14047 PyObject *resultobj = 0;
14048 wxImage *arg1 = (wxImage *) 0 ;
14049 int arg2 ;
14050 int arg3 ;
14051 byte result;
14052 void *argp1 = 0 ;
14053 int res1 = 0 ;
14054 int val2 ;
14055 int ecode2 = 0 ;
14056 int val3 ;
14057 int ecode3 = 0 ;
14058 PyObject * obj0 = 0 ;
14059 PyObject * obj1 = 0 ;
14060 PyObject * obj2 = 0 ;
14061 char * kwnames[] = {
14062 (char *) "self",(char *) "x",(char *) "y", NULL
14063 };
14064
14065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14067 if (!SWIG_IsOK(res1)) {
14068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14069 }
14070 arg1 = reinterpret_cast< wxImage * >(argp1);
14071 ecode2 = SWIG_AsVal_int(obj1, &val2);
14072 if (!SWIG_IsOK(ecode2)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14074 }
14075 arg2 = static_cast< int >(val2);
14076 ecode3 = SWIG_AsVal_int(obj2, &val3);
14077 if (!SWIG_IsOK(ecode3)) {
14078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14079 }
14080 arg3 = static_cast< int >(val3);
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 result = (byte)(arg1)->GetGreen(arg2,arg3);
14084 wxPyEndAllowThreads(__tstate);
14085 if (PyErr_Occurred()) SWIG_fail;
14086 }
14087 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj = 0;
14096 wxImage *arg1 = (wxImage *) 0 ;
14097 int arg2 ;
14098 int arg3 ;
14099 byte result;
14100 void *argp1 = 0 ;
14101 int res1 = 0 ;
14102 int val2 ;
14103 int ecode2 = 0 ;
14104 int val3 ;
14105 int ecode3 = 0 ;
14106 PyObject * obj0 = 0 ;
14107 PyObject * obj1 = 0 ;
14108 PyObject * obj2 = 0 ;
14109 char * kwnames[] = {
14110 (char *) "self",(char *) "x",(char *) "y", NULL
14111 };
14112
14113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14115 if (!SWIG_IsOK(res1)) {
14116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14117 }
14118 arg1 = reinterpret_cast< wxImage * >(argp1);
14119 ecode2 = SWIG_AsVal_int(obj1, &val2);
14120 if (!SWIG_IsOK(ecode2)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14122 }
14123 arg2 = static_cast< int >(val2);
14124 ecode3 = SWIG_AsVal_int(obj2, &val3);
14125 if (!SWIG_IsOK(ecode3)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14127 }
14128 arg3 = static_cast< int >(val3);
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (byte)(arg1)->GetBlue(arg2,arg3);
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj = 0;
14144 wxImage *arg1 = (wxImage *) 0 ;
14145 int arg2 ;
14146 int arg3 ;
14147 byte arg4 ;
14148 void *argp1 = 0 ;
14149 int res1 = 0 ;
14150 int val2 ;
14151 int ecode2 = 0 ;
14152 int val3 ;
14153 int ecode3 = 0 ;
14154 unsigned char val4 ;
14155 int ecode4 = 0 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 PyObject * obj2 = 0 ;
14159 PyObject * obj3 = 0 ;
14160 char * kwnames[] = {
14161 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14162 };
14163
14164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14166 if (!SWIG_IsOK(res1)) {
14167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14168 }
14169 arg1 = reinterpret_cast< wxImage * >(argp1);
14170 ecode2 = SWIG_AsVal_int(obj1, &val2);
14171 if (!SWIG_IsOK(ecode2)) {
14172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14173 }
14174 arg2 = static_cast< int >(val2);
14175 ecode3 = SWIG_AsVal_int(obj2, &val3);
14176 if (!SWIG_IsOK(ecode3)) {
14177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14178 }
14179 arg3 = static_cast< int >(val3);
14180 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14181 if (!SWIG_IsOK(ecode4)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14183 }
14184 arg4 = static_cast< byte >(val4);
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 (arg1)->SetAlpha(arg2,arg3,arg4);
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = SWIG_Py_Void();
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj = 0;
14200 wxImage *arg1 = (wxImage *) 0 ;
14201 int arg2 ;
14202 int arg3 ;
14203 byte result;
14204 void *argp1 = 0 ;
14205 int res1 = 0 ;
14206 int val2 ;
14207 int ecode2 = 0 ;
14208 int val3 ;
14209 int ecode3 = 0 ;
14210 PyObject * obj0 = 0 ;
14211 PyObject * obj1 = 0 ;
14212 PyObject * obj2 = 0 ;
14213 char * kwnames[] = {
14214 (char *) "self",(char *) "x",(char *) "y", NULL
14215 };
14216
14217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14219 if (!SWIG_IsOK(res1)) {
14220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14221 }
14222 arg1 = reinterpret_cast< wxImage * >(argp1);
14223 ecode2 = SWIG_AsVal_int(obj1, &val2);
14224 if (!SWIG_IsOK(ecode2)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14226 }
14227 arg2 = static_cast< int >(val2);
14228 ecode3 = SWIG_AsVal_int(obj2, &val3);
14229 if (!SWIG_IsOK(ecode3)) {
14230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14231 }
14232 arg3 = static_cast< int >(val3);
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14236 wxPyEndAllowThreads(__tstate);
14237 if (PyErr_Occurred()) SWIG_fail;
14238 }
14239 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 PyObject *resultobj = 0;
14248 wxImage *arg1 = (wxImage *) 0 ;
14249 bool result;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 PyObject *swig_obj[1] ;
14253
14254 if (!args) SWIG_fail;
14255 swig_obj[0] = args;
14256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14257 if (!SWIG_IsOK(res1)) {
14258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14259 }
14260 arg1 = reinterpret_cast< wxImage * >(argp1);
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 result = (bool)(arg1)->HasAlpha();
14264 wxPyEndAllowThreads(__tstate);
14265 if (PyErr_Occurred()) SWIG_fail;
14266 }
14267 {
14268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14269 }
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14277 PyObject *resultobj = 0;
14278 wxImage *arg1 = (wxImage *) 0 ;
14279 void *argp1 = 0 ;
14280 int res1 = 0 ;
14281 PyObject *swig_obj[1] ;
14282
14283 if (!args) SWIG_fail;
14284 swig_obj[0] = args;
14285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14286 if (!SWIG_IsOK(res1)) {
14287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14288 }
14289 arg1 = reinterpret_cast< wxImage * >(argp1);
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 (arg1)->InitAlpha();
14293 wxPyEndAllowThreads(__tstate);
14294 if (PyErr_Occurred()) SWIG_fail;
14295 }
14296 resultobj = SWIG_Py_Void();
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14304 PyObject *resultobj = 0;
14305 wxImage *arg1 = (wxImage *) 0 ;
14306 int arg2 ;
14307 int arg3 ;
14308 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14309 bool result;
14310 void *argp1 = 0 ;
14311 int res1 = 0 ;
14312 int val2 ;
14313 int ecode2 = 0 ;
14314 int val3 ;
14315 int ecode3 = 0 ;
14316 unsigned char val4 ;
14317 int ecode4 = 0 ;
14318 PyObject * obj0 = 0 ;
14319 PyObject * obj1 = 0 ;
14320 PyObject * obj2 = 0 ;
14321 PyObject * obj3 = 0 ;
14322 char * kwnames[] = {
14323 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14324 };
14325
14326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14328 if (!SWIG_IsOK(res1)) {
14329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14330 }
14331 arg1 = reinterpret_cast< wxImage * >(argp1);
14332 ecode2 = SWIG_AsVal_int(obj1, &val2);
14333 if (!SWIG_IsOK(ecode2)) {
14334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14335 }
14336 arg2 = static_cast< int >(val2);
14337 ecode3 = SWIG_AsVal_int(obj2, &val3);
14338 if (!SWIG_IsOK(ecode3)) {
14339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14340 }
14341 arg3 = static_cast< int >(val3);
14342 if (obj3) {
14343 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14344 if (!SWIG_IsOK(ecode4)) {
14345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14346 }
14347 arg4 = static_cast< byte >(val4);
14348 }
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 {
14356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14357 }
14358 return resultobj;
14359 fail:
14360 return NULL;
14361 }
14362
14363
14364 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14365 PyObject *resultobj = 0;
14366 wxImage *arg1 = (wxImage *) 0 ;
14367 byte *arg2 = (byte *) 0 ;
14368 byte *arg3 = (byte *) 0 ;
14369 byte *arg4 = (byte *) 0 ;
14370 byte arg5 = (byte) 0 ;
14371 byte arg6 = (byte) 0 ;
14372 byte arg7 = (byte) 0 ;
14373 bool result;
14374 void *argp1 = 0 ;
14375 int res1 = 0 ;
14376 byte temp2 ;
14377 int res2 = SWIG_TMPOBJ ;
14378 byte temp3 ;
14379 int res3 = SWIG_TMPOBJ ;
14380 byte temp4 ;
14381 int res4 = SWIG_TMPOBJ ;
14382 unsigned char val5 ;
14383 int ecode5 = 0 ;
14384 unsigned char val6 ;
14385 int ecode6 = 0 ;
14386 unsigned char val7 ;
14387 int ecode7 = 0 ;
14388 PyObject * obj0 = 0 ;
14389 PyObject * obj1 = 0 ;
14390 PyObject * obj2 = 0 ;
14391 PyObject * obj3 = 0 ;
14392 char * kwnames[] = {
14393 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14394 };
14395
14396 arg2 = &temp2;
14397 arg3 = &temp3;
14398 arg4 = &temp4;
14399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14401 if (!SWIG_IsOK(res1)) {
14402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14403 }
14404 arg1 = reinterpret_cast< wxImage * >(argp1);
14405 if (obj1) {
14406 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14407 if (!SWIG_IsOK(ecode5)) {
14408 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14409 }
14410 arg5 = static_cast< byte >(val5);
14411 }
14412 if (obj2) {
14413 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14414 if (!SWIG_IsOK(ecode6)) {
14415 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14416 }
14417 arg6 = static_cast< byte >(val6);
14418 }
14419 if (obj3) {
14420 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14421 if (!SWIG_IsOK(ecode7)) {
14422 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14423 }
14424 arg7 = static_cast< byte >(val7);
14425 }
14426 {
14427 PyThreadState* __tstate = wxPyBeginAllowThreads();
14428 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 {
14433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14434 }
14435 if (SWIG_IsTmpObj(res2)) {
14436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14437 } else {
14438 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14440 }
14441 if (SWIG_IsTmpObj(res3)) {
14442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14443 } else {
14444 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14446 }
14447 if (SWIG_IsTmpObj(res4)) {
14448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14449 } else {
14450 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj = 0;
14461 wxImage *arg1 = (wxImage *) 0 ;
14462 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14463 bool result;
14464 void *argp1 = 0 ;
14465 int res1 = 0 ;
14466 unsigned char val2 ;
14467 int ecode2 = 0 ;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 char * kwnames[] = {
14471 (char *) "self",(char *) "threshold", NULL
14472 };
14473
14474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14476 if (!SWIG_IsOK(res1)) {
14477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14478 }
14479 arg1 = reinterpret_cast< wxImage * >(argp1);
14480 if (obj1) {
14481 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14482 if (!SWIG_IsOK(ecode2)) {
14483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14484 }
14485 arg2 = static_cast< byte >(val2);
14486 }
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 {
14494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14495 }
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj = 0;
14504 wxImage *arg1 = (wxImage *) 0 ;
14505 byte arg2 ;
14506 byte arg3 ;
14507 byte arg4 ;
14508 bool result;
14509 void *argp1 = 0 ;
14510 int res1 = 0 ;
14511 unsigned char val2 ;
14512 int ecode2 = 0 ;
14513 unsigned char val3 ;
14514 int ecode3 = 0 ;
14515 unsigned char val4 ;
14516 int ecode4 = 0 ;
14517 PyObject * obj0 = 0 ;
14518 PyObject * obj1 = 0 ;
14519 PyObject * obj2 = 0 ;
14520 PyObject * obj3 = 0 ;
14521 char * kwnames[] = {
14522 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14523 };
14524
14525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14527 if (!SWIG_IsOK(res1)) {
14528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14529 }
14530 arg1 = reinterpret_cast< wxImage * >(argp1);
14531 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14532 if (!SWIG_IsOK(ecode2)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14534 }
14535 arg2 = static_cast< byte >(val2);
14536 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14537 if (!SWIG_IsOK(ecode3)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14539 }
14540 arg3 = static_cast< byte >(val3);
14541 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14542 if (!SWIG_IsOK(ecode4)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14544 }
14545 arg4 = static_cast< byte >(val4);
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 {
14553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14554 }
14555 return resultobj;
14556 fail:
14557 return NULL;
14558 }
14559
14560
14561 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14562 PyObject *resultobj = 0;
14563 wxImage *arg1 = (wxImage *) 0 ;
14564 wxImage *arg2 = 0 ;
14565 byte arg3 ;
14566 byte arg4 ;
14567 byte arg5 ;
14568 bool result;
14569 void *argp1 = 0 ;
14570 int res1 = 0 ;
14571 void *argp2 = 0 ;
14572 int res2 = 0 ;
14573 unsigned char val3 ;
14574 int ecode3 = 0 ;
14575 unsigned char val4 ;
14576 int ecode4 = 0 ;
14577 unsigned char val5 ;
14578 int ecode5 = 0 ;
14579 PyObject * obj0 = 0 ;
14580 PyObject * obj1 = 0 ;
14581 PyObject * obj2 = 0 ;
14582 PyObject * obj3 = 0 ;
14583 PyObject * obj4 = 0 ;
14584 char * kwnames[] = {
14585 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14586 };
14587
14588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14590 if (!SWIG_IsOK(res1)) {
14591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14592 }
14593 arg1 = reinterpret_cast< wxImage * >(argp1);
14594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14595 if (!SWIG_IsOK(res2)) {
14596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14597 }
14598 if (!argp2) {
14599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14600 }
14601 arg2 = reinterpret_cast< wxImage * >(argp2);
14602 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14603 if (!SWIG_IsOK(ecode3)) {
14604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14605 }
14606 arg3 = static_cast< byte >(val3);
14607 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14608 if (!SWIG_IsOK(ecode4)) {
14609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14610 }
14611 arg4 = static_cast< byte >(val4);
14612 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14613 if (!SWIG_IsOK(ecode5)) {
14614 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14615 }
14616 arg5 = static_cast< byte >(val5);
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 {
14624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14625 }
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj = 0;
14634 wxString *arg1 = 0 ;
14635 bool result;
14636 bool temp1 = false ;
14637 PyObject * obj0 = 0 ;
14638 char * kwnames[] = {
14639 (char *) "filename", NULL
14640 };
14641
14642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14643 {
14644 arg1 = wxString_in_helper(obj0);
14645 if (arg1 == NULL) SWIG_fail;
14646 temp1 = true;
14647 }
14648 {
14649 PyThreadState* __tstate = wxPyBeginAllowThreads();
14650 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14651 wxPyEndAllowThreads(__tstate);
14652 if (PyErr_Occurred()) SWIG_fail;
14653 }
14654 {
14655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14656 }
14657 {
14658 if (temp1)
14659 delete arg1;
14660 }
14661 return resultobj;
14662 fail:
14663 {
14664 if (temp1)
14665 delete arg1;
14666 }
14667 return NULL;
14668 }
14669
14670
14671 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj = 0;
14673 wxString *arg1 = 0 ;
14674 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14675 int result;
14676 bool temp1 = false ;
14677 long val2 ;
14678 int ecode2 = 0 ;
14679 PyObject * obj0 = 0 ;
14680 PyObject * obj1 = 0 ;
14681 char * kwnames[] = {
14682 (char *) "filename",(char *) "type", NULL
14683 };
14684
14685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14686 {
14687 arg1 = wxString_in_helper(obj0);
14688 if (arg1 == NULL) SWIG_fail;
14689 temp1 = true;
14690 }
14691 if (obj1) {
14692 ecode2 = SWIG_AsVal_long(obj1, &val2);
14693 if (!SWIG_IsOK(ecode2)) {
14694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14695 }
14696 arg2 = static_cast< long >(val2);
14697 }
14698 {
14699 PyThreadState* __tstate = wxPyBeginAllowThreads();
14700 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14701 wxPyEndAllowThreads(__tstate);
14702 if (PyErr_Occurred()) SWIG_fail;
14703 }
14704 resultobj = SWIG_From_int(static_cast< int >(result));
14705 {
14706 if (temp1)
14707 delete arg1;
14708 }
14709 return resultobj;
14710 fail:
14711 {
14712 if (temp1)
14713 delete arg1;
14714 }
14715 return NULL;
14716 }
14717
14718
14719 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14720 PyObject *resultobj = 0;
14721 wxImage *arg1 = (wxImage *) 0 ;
14722 wxString *arg2 = 0 ;
14723 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14724 int arg4 = (int) -1 ;
14725 bool result;
14726 void *argp1 = 0 ;
14727 int res1 = 0 ;
14728 bool temp2 = false ;
14729 long val3 ;
14730 int ecode3 = 0 ;
14731 int val4 ;
14732 int ecode4 = 0 ;
14733 PyObject * obj0 = 0 ;
14734 PyObject * obj1 = 0 ;
14735 PyObject * obj2 = 0 ;
14736 PyObject * obj3 = 0 ;
14737 char * kwnames[] = {
14738 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14739 };
14740
14741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14745 }
14746 arg1 = reinterpret_cast< wxImage * >(argp1);
14747 {
14748 arg2 = wxString_in_helper(obj1);
14749 if (arg2 == NULL) SWIG_fail;
14750 temp2 = true;
14751 }
14752 if (obj2) {
14753 ecode3 = SWIG_AsVal_long(obj2, &val3);
14754 if (!SWIG_IsOK(ecode3)) {
14755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14756 }
14757 arg3 = static_cast< long >(val3);
14758 }
14759 if (obj3) {
14760 ecode4 = SWIG_AsVal_int(obj3, &val4);
14761 if (!SWIG_IsOK(ecode4)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14763 }
14764 arg4 = static_cast< int >(val4);
14765 }
14766 {
14767 PyThreadState* __tstate = wxPyBeginAllowThreads();
14768 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14769 wxPyEndAllowThreads(__tstate);
14770 if (PyErr_Occurred()) SWIG_fail;
14771 }
14772 {
14773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14774 }
14775 {
14776 if (temp2)
14777 delete arg2;
14778 }
14779 return resultobj;
14780 fail:
14781 {
14782 if (temp2)
14783 delete arg2;
14784 }
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj = 0;
14791 wxImage *arg1 = (wxImage *) 0 ;
14792 wxString *arg2 = 0 ;
14793 wxString *arg3 = 0 ;
14794 int arg4 = (int) -1 ;
14795 bool result;
14796 void *argp1 = 0 ;
14797 int res1 = 0 ;
14798 bool temp2 = false ;
14799 bool temp3 = false ;
14800 int val4 ;
14801 int ecode4 = 0 ;
14802 PyObject * obj0 = 0 ;
14803 PyObject * obj1 = 0 ;
14804 PyObject * obj2 = 0 ;
14805 PyObject * obj3 = 0 ;
14806 char * kwnames[] = {
14807 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14808 };
14809
14810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14812 if (!SWIG_IsOK(res1)) {
14813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14814 }
14815 arg1 = reinterpret_cast< wxImage * >(argp1);
14816 {
14817 arg2 = wxString_in_helper(obj1);
14818 if (arg2 == NULL) SWIG_fail;
14819 temp2 = true;
14820 }
14821 {
14822 arg3 = wxString_in_helper(obj2);
14823 if (arg3 == NULL) SWIG_fail;
14824 temp3 = true;
14825 }
14826 if (obj3) {
14827 ecode4 = SWIG_AsVal_int(obj3, &val4);
14828 if (!SWIG_IsOK(ecode4)) {
14829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14830 }
14831 arg4 = static_cast< int >(val4);
14832 }
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 {
14840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14841 }
14842 {
14843 if (temp2)
14844 delete arg2;
14845 }
14846 {
14847 if (temp3)
14848 delete arg3;
14849 }
14850 return resultobj;
14851 fail:
14852 {
14853 if (temp2)
14854 delete arg2;
14855 }
14856 {
14857 if (temp3)
14858 delete arg3;
14859 }
14860 return NULL;
14861 }
14862
14863
14864 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14865 PyObject *resultobj = 0;
14866 wxImage *arg1 = (wxImage *) 0 ;
14867 wxString *arg2 = 0 ;
14868 int arg3 ;
14869 bool result;
14870 void *argp1 = 0 ;
14871 int res1 = 0 ;
14872 bool temp2 = false ;
14873 int val3 ;
14874 int ecode3 = 0 ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 PyObject * obj2 = 0 ;
14878 char * kwnames[] = {
14879 (char *) "self",(char *) "name",(char *) "type", NULL
14880 };
14881
14882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14884 if (!SWIG_IsOK(res1)) {
14885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14886 }
14887 arg1 = reinterpret_cast< wxImage * >(argp1);
14888 {
14889 arg2 = wxString_in_helper(obj1);
14890 if (arg2 == NULL) SWIG_fail;
14891 temp2 = true;
14892 }
14893 ecode3 = SWIG_AsVal_int(obj2, &val3);
14894 if (!SWIG_IsOK(ecode3)) {
14895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14896 }
14897 arg3 = static_cast< int >(val3);
14898 {
14899 PyThreadState* __tstate = wxPyBeginAllowThreads();
14900 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 {
14905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14906 }
14907 {
14908 if (temp2)
14909 delete arg2;
14910 }
14911 return resultobj;
14912 fail:
14913 {
14914 if (temp2)
14915 delete arg2;
14916 }
14917 return NULL;
14918 }
14919
14920
14921 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14922 PyObject *resultobj = 0;
14923 wxImage *arg1 = (wxImage *) 0 ;
14924 wxString *arg2 = 0 ;
14925 wxString *arg3 = 0 ;
14926 bool result;
14927 void *argp1 = 0 ;
14928 int res1 = 0 ;
14929 bool temp2 = false ;
14930 bool temp3 = false ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 PyObject * obj2 = 0 ;
14934 char * kwnames[] = {
14935 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14936 };
14937
14938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14940 if (!SWIG_IsOK(res1)) {
14941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14942 }
14943 arg1 = reinterpret_cast< wxImage * >(argp1);
14944 {
14945 arg2 = wxString_in_helper(obj1);
14946 if (arg2 == NULL) SWIG_fail;
14947 temp2 = true;
14948 }
14949 {
14950 arg3 = wxString_in_helper(obj2);
14951 if (arg3 == NULL) SWIG_fail;
14952 temp3 = true;
14953 }
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 {
14961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14962 }
14963 {
14964 if (temp2)
14965 delete arg2;
14966 }
14967 {
14968 if (temp3)
14969 delete arg3;
14970 }
14971 return resultobj;
14972 fail:
14973 {
14974 if (temp2)
14975 delete arg2;
14976 }
14977 {
14978 if (temp3)
14979 delete arg3;
14980 }
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14986 PyObject *resultobj = 0;
14987 wxInputStream *arg1 = 0 ;
14988 bool result;
14989 wxPyInputStream *temp1 ;
14990 bool created1 ;
14991 PyObject * obj0 = 0 ;
14992 char * kwnames[] = {
14993 (char *) "stream", NULL
14994 };
14995
14996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14997 {
14998 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14999 arg1 = temp1->m_wxis;
15000 created1 = false;
15001 } else {
15002 PyErr_Clear(); // clear the failure of the wxPyConvert above
15003 arg1 = wxPyCBInputStream_create(obj0, false);
15004 if (arg1 == NULL) {
15005 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15006 SWIG_fail;
15007 }
15008 created1 = true;
15009 }
15010 }
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 result = (bool)wxImage::CanRead(*arg1);
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 {
15018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15019 }
15020 {
15021 if (created1) delete arg1;
15022 }
15023 return resultobj;
15024 fail:
15025 {
15026 if (created1) delete arg1;
15027 }
15028 return NULL;
15029 }
15030
15031
15032 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15033 PyObject *resultobj = 0;
15034 wxImage *arg1 = (wxImage *) 0 ;
15035 wxInputStream *arg2 = 0 ;
15036 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15037 int arg4 = (int) -1 ;
15038 bool result;
15039 void *argp1 = 0 ;
15040 int res1 = 0 ;
15041 wxPyInputStream *temp2 ;
15042 bool created2 ;
15043 long val3 ;
15044 int ecode3 = 0 ;
15045 int val4 ;
15046 int ecode4 = 0 ;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 PyObject * obj2 = 0 ;
15050 PyObject * obj3 = 0 ;
15051 char * kwnames[] = {
15052 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15053 };
15054
15055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15057 if (!SWIG_IsOK(res1)) {
15058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15059 }
15060 arg1 = reinterpret_cast< wxImage * >(argp1);
15061 {
15062 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15063 arg2 = temp2->m_wxis;
15064 created2 = false;
15065 } else {
15066 PyErr_Clear(); // clear the failure of the wxPyConvert above
15067 arg2 = wxPyCBInputStream_create(obj1, false);
15068 if (arg2 == NULL) {
15069 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15070 SWIG_fail;
15071 }
15072 created2 = true;
15073 }
15074 }
15075 if (obj2) {
15076 ecode3 = SWIG_AsVal_long(obj2, &val3);
15077 if (!SWIG_IsOK(ecode3)) {
15078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15079 }
15080 arg3 = static_cast< long >(val3);
15081 }
15082 if (obj3) {
15083 ecode4 = SWIG_AsVal_int(obj3, &val4);
15084 if (!SWIG_IsOK(ecode4)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15086 }
15087 arg4 = static_cast< int >(val4);
15088 }
15089 {
15090 PyThreadState* __tstate = wxPyBeginAllowThreads();
15091 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15092 wxPyEndAllowThreads(__tstate);
15093 if (PyErr_Occurred()) SWIG_fail;
15094 }
15095 {
15096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15097 }
15098 {
15099 if (created2) delete arg2;
15100 }
15101 return resultobj;
15102 fail:
15103 {
15104 if (created2) delete arg2;
15105 }
15106 return NULL;
15107 }
15108
15109
15110 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15111 PyObject *resultobj = 0;
15112 wxImage *arg1 = (wxImage *) 0 ;
15113 wxInputStream *arg2 = 0 ;
15114 wxString *arg3 = 0 ;
15115 int arg4 = (int) -1 ;
15116 bool result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 wxPyInputStream *temp2 ;
15120 bool created2 ;
15121 bool temp3 = false ;
15122 int val4 ;
15123 int ecode4 = 0 ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 PyObject * obj3 = 0 ;
15128 char * kwnames[] = {
15129 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15130 };
15131
15132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15134 if (!SWIG_IsOK(res1)) {
15135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15136 }
15137 arg1 = reinterpret_cast< wxImage * >(argp1);
15138 {
15139 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15140 arg2 = temp2->m_wxis;
15141 created2 = false;
15142 } else {
15143 PyErr_Clear(); // clear the failure of the wxPyConvert above
15144 arg2 = wxPyCBInputStream_create(obj1, false);
15145 if (arg2 == NULL) {
15146 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15147 SWIG_fail;
15148 }
15149 created2 = true;
15150 }
15151 }
15152 {
15153 arg3 = wxString_in_helper(obj2);
15154 if (arg3 == NULL) SWIG_fail;
15155 temp3 = true;
15156 }
15157 if (obj3) {
15158 ecode4 = SWIG_AsVal_int(obj3, &val4);
15159 if (!SWIG_IsOK(ecode4)) {
15160 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15161 }
15162 arg4 = static_cast< int >(val4);
15163 }
15164 {
15165 PyThreadState* __tstate = wxPyBeginAllowThreads();
15166 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 {
15171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15172 }
15173 {
15174 if (created2) delete arg2;
15175 }
15176 {
15177 if (temp3)
15178 delete arg3;
15179 }
15180 return resultobj;
15181 fail:
15182 {
15183 if (created2) delete arg2;
15184 }
15185 {
15186 if (temp3)
15187 delete arg3;
15188 }
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 PyObject *resultobj = 0;
15195 wxImage *arg1 = (wxImage *) 0 ;
15196 bool result;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 PyObject *swig_obj[1] ;
15200
15201 if (!args) SWIG_fail;
15202 swig_obj[0] = args;
15203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15204 if (!SWIG_IsOK(res1)) {
15205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15206 }
15207 arg1 = reinterpret_cast< wxImage * >(argp1);
15208 {
15209 PyThreadState* __tstate = wxPyBeginAllowThreads();
15210 result = (bool)(arg1)->Ok();
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 {
15215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15216 }
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15224 PyObject *resultobj = 0;
15225 wxImage *arg1 = (wxImage *) 0 ;
15226 int result;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 PyObject *swig_obj[1] ;
15230
15231 if (!args) SWIG_fail;
15232 swig_obj[0] = args;
15233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15234 if (!SWIG_IsOK(res1)) {
15235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15236 }
15237 arg1 = reinterpret_cast< wxImage * >(argp1);
15238 {
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 result = (int)(arg1)->GetWidth();
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 resultobj = SWIG_From_int(static_cast< int >(result));
15245 return resultobj;
15246 fail:
15247 return NULL;
15248 }
15249
15250
15251 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15252 PyObject *resultobj = 0;
15253 wxImage *arg1 = (wxImage *) 0 ;
15254 int result;
15255 void *argp1 = 0 ;
15256 int res1 = 0 ;
15257 PyObject *swig_obj[1] ;
15258
15259 if (!args) SWIG_fail;
15260 swig_obj[0] = args;
15261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15262 if (!SWIG_IsOK(res1)) {
15263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15264 }
15265 arg1 = reinterpret_cast< wxImage * >(argp1);
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (int)(arg1)->GetHeight();
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 resultobj = SWIG_From_int(static_cast< int >(result));
15273 return resultobj;
15274 fail:
15275 return NULL;
15276 }
15277
15278
15279 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15280 PyObject *resultobj = 0;
15281 wxImage *arg1 = (wxImage *) 0 ;
15282 wxSize result;
15283 void *argp1 = 0 ;
15284 int res1 = 0 ;
15285 PyObject *swig_obj[1] ;
15286
15287 if (!args) SWIG_fail;
15288 swig_obj[0] = args;
15289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15290 if (!SWIG_IsOK(res1)) {
15291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15292 }
15293 arg1 = reinterpret_cast< wxImage * >(argp1);
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 result = wxImage_GetSize(arg1);
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15308 PyObject *resultobj = 0;
15309 wxImage *arg1 = (wxImage *) 0 ;
15310 wxRect *arg2 = 0 ;
15311 SwigValueWrapper<wxImage > result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 wxRect temp2 ;
15315 PyObject * obj0 = 0 ;
15316 PyObject * obj1 = 0 ;
15317 char * kwnames[] = {
15318 (char *) "self",(char *) "rect", NULL
15319 };
15320
15321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15323 if (!SWIG_IsOK(res1)) {
15324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15325 }
15326 arg1 = reinterpret_cast< wxImage * >(argp1);
15327 {
15328 arg2 = &temp2;
15329 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15330 }
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15334 wxPyEndAllowThreads(__tstate);
15335 if (PyErr_Occurred()) SWIG_fail;
15336 }
15337 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15338 return resultobj;
15339 fail:
15340 return NULL;
15341 }
15342
15343
15344 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15345 PyObject *resultobj = 0;
15346 wxImage *arg1 = (wxImage *) 0 ;
15347 wxSize *arg2 = 0 ;
15348 wxPoint *arg3 = 0 ;
15349 int arg4 = (int) -1 ;
15350 int arg5 = (int) -1 ;
15351 int arg6 = (int) -1 ;
15352 SwigValueWrapper<wxImage > result;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 wxSize temp2 ;
15356 wxPoint temp3 ;
15357 int val4 ;
15358 int ecode4 = 0 ;
15359 int val5 ;
15360 int ecode5 = 0 ;
15361 int val6 ;
15362 int ecode6 = 0 ;
15363 PyObject * obj0 = 0 ;
15364 PyObject * obj1 = 0 ;
15365 PyObject * obj2 = 0 ;
15366 PyObject * obj3 = 0 ;
15367 PyObject * obj4 = 0 ;
15368 PyObject * obj5 = 0 ;
15369 char * kwnames[] = {
15370 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15371 };
15372
15373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15377 }
15378 arg1 = reinterpret_cast< wxImage * >(argp1);
15379 {
15380 arg2 = &temp2;
15381 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15382 }
15383 {
15384 arg3 = &temp3;
15385 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15386 }
15387 if (obj3) {
15388 ecode4 = SWIG_AsVal_int(obj3, &val4);
15389 if (!SWIG_IsOK(ecode4)) {
15390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15391 }
15392 arg4 = static_cast< int >(val4);
15393 }
15394 if (obj4) {
15395 ecode5 = SWIG_AsVal_int(obj4, &val5);
15396 if (!SWIG_IsOK(ecode5)) {
15397 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15398 }
15399 arg5 = static_cast< int >(val5);
15400 }
15401 if (obj5) {
15402 ecode6 = SWIG_AsVal_int(obj5, &val6);
15403 if (!SWIG_IsOK(ecode6)) {
15404 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15405 }
15406 arg6 = static_cast< int >(val6);
15407 }
15408 {
15409 PyThreadState* __tstate = wxPyBeginAllowThreads();
15410 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15422 PyObject *resultobj = 0;
15423 wxImage *arg1 = (wxImage *) 0 ;
15424 SwigValueWrapper<wxImage > result;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 PyObject *swig_obj[1] ;
15428
15429 if (!args) SWIG_fail;
15430 swig_obj[0] = args;
15431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15432 if (!SWIG_IsOK(res1)) {
15433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15434 }
15435 arg1 = reinterpret_cast< wxImage * >(argp1);
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 result = (arg1)->Copy();
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj = 0;
15451 wxImage *arg1 = (wxImage *) 0 ;
15452 wxImage *arg2 = 0 ;
15453 int arg3 ;
15454 int arg4 ;
15455 void *argp1 = 0 ;
15456 int res1 = 0 ;
15457 void *argp2 = 0 ;
15458 int res2 = 0 ;
15459 int val3 ;
15460 int ecode3 = 0 ;
15461 int val4 ;
15462 int ecode4 = 0 ;
15463 PyObject * obj0 = 0 ;
15464 PyObject * obj1 = 0 ;
15465 PyObject * obj2 = 0 ;
15466 PyObject * obj3 = 0 ;
15467 char * kwnames[] = {
15468 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15469 };
15470
15471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15475 }
15476 arg1 = reinterpret_cast< wxImage * >(argp1);
15477 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15478 if (!SWIG_IsOK(res2)) {
15479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15480 }
15481 if (!argp2) {
15482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15483 }
15484 arg2 = reinterpret_cast< wxImage * >(argp2);
15485 ecode3 = SWIG_AsVal_int(obj2, &val3);
15486 if (!SWIG_IsOK(ecode3)) {
15487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15488 }
15489 arg3 = static_cast< int >(val3);
15490 ecode4 = SWIG_AsVal_int(obj3, &val4);
15491 if (!SWIG_IsOK(ecode4)) {
15492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15493 }
15494 arg4 = static_cast< int >(val4);
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15498 wxPyEndAllowThreads(__tstate);
15499 if (PyErr_Occurred()) SWIG_fail;
15500 }
15501 resultobj = SWIG_Py_Void();
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15509 PyObject *resultobj = 0;
15510 wxImage *arg1 = (wxImage *) 0 ;
15511 PyObject *result = 0 ;
15512 void *argp1 = 0 ;
15513 int res1 = 0 ;
15514 PyObject *swig_obj[1] ;
15515
15516 if (!args) SWIG_fail;
15517 swig_obj[0] = args;
15518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15521 }
15522 arg1 = reinterpret_cast< wxImage * >(argp1);
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 result = (PyObject *)wxImage_GetData(arg1);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = result;
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj = 0;
15538 wxImage *arg1 = (wxImage *) 0 ;
15539 buffer arg2 ;
15540 int arg3 ;
15541 void *argp1 = 0 ;
15542 int res1 = 0 ;
15543 Py_ssize_t temp2 ;
15544 PyObject * obj0 = 0 ;
15545 PyObject * obj1 = 0 ;
15546 char * kwnames[] = {
15547 (char *) "self",(char *) "data", NULL
15548 };
15549
15550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15554 }
15555 arg1 = reinterpret_cast< wxImage * >(argp1);
15556 {
15557 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15558 arg3 = (int)temp2;
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 wxImage_SetData(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_GetDataBuffer(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_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15586 }
15587 arg1 = reinterpret_cast< wxImage * >(argp1);
15588 {
15589 PyThreadState* __tstate = wxPyBeginAllowThreads();
15590 result = (PyObject *)wxImage_GetDataBuffer(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_SetDataBuffer(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 Py_ssize_t temp2 ;
15609 PyObject * obj0 = 0 ;
15610 PyObject * obj1 = 0 ;
15611 char * kwnames[] = {
15612 (char *) "self",(char *) "data", NULL
15613 };
15614
15615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15617 if (!SWIG_IsOK(res1)) {
15618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15619 }
15620 arg1 = reinterpret_cast< wxImage * >(argp1);
15621 {
15622 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15623 arg3 = (int)temp2;
15624 }
15625 {
15626 PyThreadState* __tstate = wxPyBeginAllowThreads();
15627 wxImage_SetDataBuffer(arg1,arg2,arg3);
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 resultobj = SWIG_Py_Void();
15632 return resultobj;
15633 fail:
15634 return NULL;
15635 }
15636
15637
15638 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15639 PyObject *resultobj = 0;
15640 wxImage *arg1 = (wxImage *) 0 ;
15641 PyObject *result = 0 ;
15642 void *argp1 = 0 ;
15643 int res1 = 0 ;
15644 PyObject *swig_obj[1] ;
15645
15646 if (!args) SWIG_fail;
15647 swig_obj[0] = args;
15648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15649 if (!SWIG_IsOK(res1)) {
15650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15651 }
15652 arg1 = reinterpret_cast< wxImage * >(argp1);
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 result = (PyObject *)wxImage_GetAlphaData(arg1);
15656 wxPyEndAllowThreads(__tstate);
15657 if (PyErr_Occurred()) SWIG_fail;
15658 }
15659 resultobj = result;
15660 return resultobj;
15661 fail:
15662 return NULL;
15663 }
15664
15665
15666 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15667 PyObject *resultobj = 0;
15668 wxImage *arg1 = (wxImage *) 0 ;
15669 buffer arg2 ;
15670 int arg3 ;
15671 void *argp1 = 0 ;
15672 int res1 = 0 ;
15673 Py_ssize_t temp2 ;
15674 PyObject * obj0 = 0 ;
15675 PyObject * obj1 = 0 ;
15676 char * kwnames[] = {
15677 (char *) "self",(char *) "alpha", NULL
15678 };
15679
15680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15682 if (!SWIG_IsOK(res1)) {
15683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15684 }
15685 arg1 = reinterpret_cast< wxImage * >(argp1);
15686 {
15687 if (obj1 != Py_None) {
15688 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15689 arg3 = (int)temp2;
15690 }
15691 }
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 wxImage_SetAlphaData(arg1,arg2,arg3);
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 resultobj = SWIG_Py_Void();
15699 return resultobj;
15700 fail:
15701 return NULL;
15702 }
15703
15704
15705 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15706 PyObject *resultobj = 0;
15707 wxImage *arg1 = (wxImage *) 0 ;
15708 PyObject *result = 0 ;
15709 void *argp1 = 0 ;
15710 int res1 = 0 ;
15711 PyObject *swig_obj[1] ;
15712
15713 if (!args) SWIG_fail;
15714 swig_obj[0] = args;
15715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15716 if (!SWIG_IsOK(res1)) {
15717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15718 }
15719 arg1 = reinterpret_cast< wxImage * >(argp1);
15720 {
15721 PyThreadState* __tstate = wxPyBeginAllowThreads();
15722 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15723 wxPyEndAllowThreads(__tstate);
15724 if (PyErr_Occurred()) SWIG_fail;
15725 }
15726 resultobj = result;
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj = 0;
15735 wxImage *arg1 = (wxImage *) 0 ;
15736 buffer arg2 ;
15737 int arg3 ;
15738 void *argp1 = 0 ;
15739 int res1 = 0 ;
15740 Py_ssize_t temp2 ;
15741 PyObject * obj0 = 0 ;
15742 PyObject * obj1 = 0 ;
15743 char * kwnames[] = {
15744 (char *) "self",(char *) "alpha", NULL
15745 };
15746
15747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15751 }
15752 arg1 = reinterpret_cast< wxImage * >(argp1);
15753 {
15754 if (obj1 != Py_None) {
15755 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15756 arg3 = (int)temp2;
15757 }
15758 }
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 resultobj = SWIG_Py_Void();
15766 return resultobj;
15767 fail:
15768 return NULL;
15769 }
15770
15771
15772 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15773 PyObject *resultobj = 0;
15774 wxImage *arg1 = (wxImage *) 0 ;
15775 byte arg2 ;
15776 byte arg3 ;
15777 byte arg4 ;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 unsigned char val2 ;
15781 int ecode2 = 0 ;
15782 unsigned char val3 ;
15783 int ecode3 = 0 ;
15784 unsigned char val4 ;
15785 int ecode4 = 0 ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 PyObject * obj2 = 0 ;
15789 PyObject * obj3 = 0 ;
15790 char * kwnames[] = {
15791 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15792 };
15793
15794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15796 if (!SWIG_IsOK(res1)) {
15797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15798 }
15799 arg1 = reinterpret_cast< wxImage * >(argp1);
15800 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15801 if (!SWIG_IsOK(ecode2)) {
15802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15803 }
15804 arg2 = static_cast< byte >(val2);
15805 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15806 if (!SWIG_IsOK(ecode3)) {
15807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15808 }
15809 arg3 = static_cast< byte >(val3);
15810 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15811 if (!SWIG_IsOK(ecode4)) {
15812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15813 }
15814 arg4 = static_cast< byte >(val4);
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 (arg1)->SetMaskColour(arg2,arg3,arg4);
15818 wxPyEndAllowThreads(__tstate);
15819 if (PyErr_Occurred()) SWIG_fail;
15820 }
15821 resultobj = SWIG_Py_Void();
15822 return resultobj;
15823 fail:
15824 return NULL;
15825 }
15826
15827
15828 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15829 PyObject *resultobj = 0;
15830 wxImage *arg1 = (wxImage *) 0 ;
15831 byte *arg2 = (byte *) 0 ;
15832 byte *arg3 = (byte *) 0 ;
15833 byte *arg4 = (byte *) 0 ;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 byte temp2 ;
15837 int res2 = SWIG_TMPOBJ ;
15838 byte temp3 ;
15839 int res3 = SWIG_TMPOBJ ;
15840 byte temp4 ;
15841 int res4 = SWIG_TMPOBJ ;
15842 PyObject *swig_obj[1] ;
15843
15844 arg2 = &temp2;
15845 arg3 = &temp3;
15846 arg4 = &temp4;
15847 if (!args) SWIG_fail;
15848 swig_obj[0] = args;
15849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15850 if (!SWIG_IsOK(res1)) {
15851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15852 }
15853 arg1 = reinterpret_cast< wxImage * >(argp1);
15854 {
15855 PyThreadState* __tstate = wxPyBeginAllowThreads();
15856 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15857 wxPyEndAllowThreads(__tstate);
15858 if (PyErr_Occurred()) SWIG_fail;
15859 }
15860 resultobj = SWIG_Py_Void();
15861 if (SWIG_IsTmpObj(res2)) {
15862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15863 } else {
15864 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15866 }
15867 if (SWIG_IsTmpObj(res3)) {
15868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15869 } else {
15870 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15872 }
15873 if (SWIG_IsTmpObj(res4)) {
15874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15875 } else {
15876 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15878 }
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15886 PyObject *resultobj = 0;
15887 wxImage *arg1 = (wxImage *) 0 ;
15888 byte result;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject *swig_obj[1] ;
15892
15893 if (!args) SWIG_fail;
15894 swig_obj[0] = args;
15895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15896 if (!SWIG_IsOK(res1)) {
15897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15898 }
15899 arg1 = reinterpret_cast< wxImage * >(argp1);
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (byte)(arg1)->GetMaskRed();
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15914 PyObject *resultobj = 0;
15915 wxImage *arg1 = (wxImage *) 0 ;
15916 byte result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 PyObject *swig_obj[1] ;
15920
15921 if (!args) SWIG_fail;
15922 swig_obj[0] = args;
15923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15924 if (!SWIG_IsOK(res1)) {
15925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15926 }
15927 arg1 = reinterpret_cast< wxImage * >(argp1);
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 result = (byte)(arg1)->GetMaskGreen();
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15942 PyObject *resultobj = 0;
15943 wxImage *arg1 = (wxImage *) 0 ;
15944 byte result;
15945 void *argp1 = 0 ;
15946 int res1 = 0 ;
15947 PyObject *swig_obj[1] ;
15948
15949 if (!args) SWIG_fail;
15950 swig_obj[0] = args;
15951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15952 if (!SWIG_IsOK(res1)) {
15953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15954 }
15955 arg1 = reinterpret_cast< wxImage * >(argp1);
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 result = (byte)(arg1)->GetMaskBlue();
15959 wxPyEndAllowThreads(__tstate);
15960 if (PyErr_Occurred()) SWIG_fail;
15961 }
15962 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15963 return resultobj;
15964 fail:
15965 return NULL;
15966 }
15967
15968
15969 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj = 0;
15971 wxImage *arg1 = (wxImage *) 0 ;
15972 bool arg2 = (bool) true ;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 bool val2 ;
15976 int ecode2 = 0 ;
15977 PyObject * obj0 = 0 ;
15978 PyObject * obj1 = 0 ;
15979 char * kwnames[] = {
15980 (char *) "self",(char *) "mask", NULL
15981 };
15982
15983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15985 if (!SWIG_IsOK(res1)) {
15986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15987 }
15988 arg1 = reinterpret_cast< wxImage * >(argp1);
15989 if (obj1) {
15990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15991 if (!SWIG_IsOK(ecode2)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15993 }
15994 arg2 = static_cast< bool >(val2);
15995 }
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 (arg1)->SetMask(arg2);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_Py_Void();
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16010 PyObject *resultobj = 0;
16011 wxImage *arg1 = (wxImage *) 0 ;
16012 bool result;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16022 }
16023 arg1 = reinterpret_cast< wxImage * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (bool)(arg1)->HasMask();
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 {
16031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16032 }
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj = 0;
16041 wxImage *arg1 = (wxImage *) 0 ;
16042 double arg2 ;
16043 wxPoint *arg3 = 0 ;
16044 bool arg4 = (bool) true ;
16045 wxPoint *arg5 = (wxPoint *) NULL ;
16046 SwigValueWrapper<wxImage > result;
16047 void *argp1 = 0 ;
16048 int res1 = 0 ;
16049 double val2 ;
16050 int ecode2 = 0 ;
16051 wxPoint temp3 ;
16052 bool val4 ;
16053 int ecode4 = 0 ;
16054 void *argp5 = 0 ;
16055 int res5 = 0 ;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 PyObject * obj2 = 0 ;
16059 PyObject * obj3 = 0 ;
16060 PyObject * obj4 = 0 ;
16061 char * kwnames[] = {
16062 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16063 };
16064
16065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16069 }
16070 arg1 = reinterpret_cast< wxImage * >(argp1);
16071 ecode2 = SWIG_AsVal_double(obj1, &val2);
16072 if (!SWIG_IsOK(ecode2)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16074 }
16075 arg2 = static_cast< double >(val2);
16076 {
16077 arg3 = &temp3;
16078 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16079 }
16080 if (obj3) {
16081 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16082 if (!SWIG_IsOK(ecode4)) {
16083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16084 }
16085 arg4 = static_cast< bool >(val4);
16086 }
16087 if (obj4) {
16088 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16089 if (!SWIG_IsOK(res5)) {
16090 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16091 }
16092 arg5 = reinterpret_cast< wxPoint * >(argp5);
16093 }
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16101 return resultobj;
16102 fail:
16103 return NULL;
16104 }
16105
16106
16107 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16108 PyObject *resultobj = 0;
16109 wxImage *arg1 = (wxImage *) 0 ;
16110 bool arg2 = (bool) true ;
16111 SwigValueWrapper<wxImage > result;
16112 void *argp1 = 0 ;
16113 int res1 = 0 ;
16114 bool val2 ;
16115 int ecode2 = 0 ;
16116 PyObject * obj0 = 0 ;
16117 PyObject * obj1 = 0 ;
16118 char * kwnames[] = {
16119 (char *) "self",(char *) "clockwise", NULL
16120 };
16121
16122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16124 if (!SWIG_IsOK(res1)) {
16125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16126 }
16127 arg1 = reinterpret_cast< wxImage * >(argp1);
16128 if (obj1) {
16129 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16130 if (!SWIG_IsOK(ecode2)) {
16131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16132 }
16133 arg2 = static_cast< bool >(val2);
16134 }
16135 {
16136 PyThreadState* __tstate = wxPyBeginAllowThreads();
16137 result = (arg1)->Rotate90(arg2);
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj = 0;
16150 wxImage *arg1 = (wxImage *) 0 ;
16151 bool arg2 = (bool) true ;
16152 SwigValueWrapper<wxImage > result;
16153 void *argp1 = 0 ;
16154 int res1 = 0 ;
16155 bool val2 ;
16156 int ecode2 = 0 ;
16157 PyObject * obj0 = 0 ;
16158 PyObject * obj1 = 0 ;
16159 char * kwnames[] = {
16160 (char *) "self",(char *) "horizontally", NULL
16161 };
16162
16163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16165 if (!SWIG_IsOK(res1)) {
16166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16167 }
16168 arg1 = reinterpret_cast< wxImage * >(argp1);
16169 if (obj1) {
16170 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16171 if (!SWIG_IsOK(ecode2)) {
16172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16173 }
16174 arg2 = static_cast< bool >(val2);
16175 }
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 result = (arg1)->Mirror(arg2);
16179 wxPyEndAllowThreads(__tstate);
16180 if (PyErr_Occurred()) SWIG_fail;
16181 }
16182 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16183 return resultobj;
16184 fail:
16185 return NULL;
16186 }
16187
16188
16189 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16190 PyObject *resultobj = 0;
16191 wxImage *arg1 = (wxImage *) 0 ;
16192 byte arg2 ;
16193 byte arg3 ;
16194 byte arg4 ;
16195 byte arg5 ;
16196 byte arg6 ;
16197 byte arg7 ;
16198 void *argp1 = 0 ;
16199 int res1 = 0 ;
16200 unsigned char val2 ;
16201 int ecode2 = 0 ;
16202 unsigned char val3 ;
16203 int ecode3 = 0 ;
16204 unsigned char val4 ;
16205 int ecode4 = 0 ;
16206 unsigned char val5 ;
16207 int ecode5 = 0 ;
16208 unsigned char val6 ;
16209 int ecode6 = 0 ;
16210 unsigned char val7 ;
16211 int ecode7 = 0 ;
16212 PyObject * obj0 = 0 ;
16213 PyObject * obj1 = 0 ;
16214 PyObject * obj2 = 0 ;
16215 PyObject * obj3 = 0 ;
16216 PyObject * obj4 = 0 ;
16217 PyObject * obj5 = 0 ;
16218 PyObject * obj6 = 0 ;
16219 char * kwnames[] = {
16220 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16221 };
16222
16223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16225 if (!SWIG_IsOK(res1)) {
16226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16227 }
16228 arg1 = reinterpret_cast< wxImage * >(argp1);
16229 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16230 if (!SWIG_IsOK(ecode2)) {
16231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16232 }
16233 arg2 = static_cast< byte >(val2);
16234 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16235 if (!SWIG_IsOK(ecode3)) {
16236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16237 }
16238 arg3 = static_cast< byte >(val3);
16239 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16240 if (!SWIG_IsOK(ecode4)) {
16241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16242 }
16243 arg4 = static_cast< byte >(val4);
16244 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16245 if (!SWIG_IsOK(ecode5)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16247 }
16248 arg5 = static_cast< byte >(val5);
16249 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16250 if (!SWIG_IsOK(ecode6)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16252 }
16253 arg6 = static_cast< byte >(val6);
16254 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16255 if (!SWIG_IsOK(ecode7)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16257 }
16258 arg7 = static_cast< byte >(val7);
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 resultobj = SWIG_Py_Void();
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj = 0;
16274 wxImage *arg1 = (wxImage *) 0 ;
16275 double arg2 = (double) 0.299 ;
16276 double arg3 = (double) 0.587 ;
16277 double arg4 = (double) 0.114 ;
16278 SwigValueWrapper<wxImage > result;
16279 void *argp1 = 0 ;
16280 int res1 = 0 ;
16281 double val2 ;
16282 int ecode2 = 0 ;
16283 double val3 ;
16284 int ecode3 = 0 ;
16285 double val4 ;
16286 int ecode4 = 0 ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 PyObject * obj2 = 0 ;
16290 PyObject * obj3 = 0 ;
16291 char * kwnames[] = {
16292 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16293 };
16294
16295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16297 if (!SWIG_IsOK(res1)) {
16298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16299 }
16300 arg1 = reinterpret_cast< wxImage * >(argp1);
16301 if (obj1) {
16302 ecode2 = SWIG_AsVal_double(obj1, &val2);
16303 if (!SWIG_IsOK(ecode2)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16305 }
16306 arg2 = static_cast< double >(val2);
16307 }
16308 if (obj2) {
16309 ecode3 = SWIG_AsVal_double(obj2, &val3);
16310 if (!SWIG_IsOK(ecode3)) {
16311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16312 }
16313 arg3 = static_cast< double >(val3);
16314 }
16315 if (obj3) {
16316 ecode4 = SWIG_AsVal_double(obj3, &val4);
16317 if (!SWIG_IsOK(ecode4)) {
16318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16319 }
16320 arg4 = static_cast< double >(val4);
16321 }
16322 {
16323 PyThreadState* __tstate = wxPyBeginAllowThreads();
16324 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16329 return resultobj;
16330 fail:
16331 return NULL;
16332 }
16333
16334
16335 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16336 PyObject *resultobj = 0;
16337 wxImage *arg1 = (wxImage *) 0 ;
16338 byte arg2 ;
16339 byte arg3 ;
16340 byte arg4 ;
16341 SwigValueWrapper<wxImage > result;
16342 void *argp1 = 0 ;
16343 int res1 = 0 ;
16344 unsigned char val2 ;
16345 int ecode2 = 0 ;
16346 unsigned char val3 ;
16347 int ecode3 = 0 ;
16348 unsigned char val4 ;
16349 int ecode4 = 0 ;
16350 PyObject * obj0 = 0 ;
16351 PyObject * obj1 = 0 ;
16352 PyObject * obj2 = 0 ;
16353 PyObject * obj3 = 0 ;
16354 char * kwnames[] = {
16355 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16356 };
16357
16358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16360 if (!SWIG_IsOK(res1)) {
16361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16362 }
16363 arg1 = reinterpret_cast< wxImage * >(argp1);
16364 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16365 if (!SWIG_IsOK(ecode2)) {
16366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16367 }
16368 arg2 = static_cast< byte >(val2);
16369 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16370 if (!SWIG_IsOK(ecode3)) {
16371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16372 }
16373 arg3 = static_cast< byte >(val3);
16374 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16375 if (!SWIG_IsOK(ecode4)) {
16376 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16377 }
16378 arg4 = static_cast< byte >(val4);
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16386 return resultobj;
16387 fail:
16388 return NULL;
16389 }
16390
16391
16392 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16393 PyObject *resultobj = 0;
16394 wxImage *arg1 = (wxImage *) 0 ;
16395 wxString *arg2 = 0 ;
16396 wxString *arg3 = 0 ;
16397 void *argp1 = 0 ;
16398 int res1 = 0 ;
16399 bool temp2 = false ;
16400 bool temp3 = false ;
16401 PyObject * obj0 = 0 ;
16402 PyObject * obj1 = 0 ;
16403 PyObject * obj2 = 0 ;
16404 char * kwnames[] = {
16405 (char *) "self",(char *) "name",(char *) "value", NULL
16406 };
16407
16408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16410 if (!SWIG_IsOK(res1)) {
16411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16412 }
16413 arg1 = reinterpret_cast< wxImage * >(argp1);
16414 {
16415 arg2 = wxString_in_helper(obj1);
16416 if (arg2 == NULL) SWIG_fail;
16417 temp2 = true;
16418 }
16419 {
16420 arg3 = wxString_in_helper(obj2);
16421 if (arg3 == NULL) SWIG_fail;
16422 temp3 = true;
16423 }
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16427 wxPyEndAllowThreads(__tstate);
16428 if (PyErr_Occurred()) SWIG_fail;
16429 }
16430 resultobj = SWIG_Py_Void();
16431 {
16432 if (temp2)
16433 delete arg2;
16434 }
16435 {
16436 if (temp3)
16437 delete arg3;
16438 }
16439 return resultobj;
16440 fail:
16441 {
16442 if (temp2)
16443 delete arg2;
16444 }
16445 {
16446 if (temp3)
16447 delete arg3;
16448 }
16449 return NULL;
16450 }
16451
16452
16453 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj = 0;
16455 wxImage *arg1 = (wxImage *) 0 ;
16456 wxString *arg2 = 0 ;
16457 int arg3 ;
16458 void *argp1 = 0 ;
16459 int res1 = 0 ;
16460 bool temp2 = false ;
16461 int val3 ;
16462 int ecode3 = 0 ;
16463 PyObject * obj0 = 0 ;
16464 PyObject * obj1 = 0 ;
16465 PyObject * obj2 = 0 ;
16466 char * kwnames[] = {
16467 (char *) "self",(char *) "name",(char *) "value", NULL
16468 };
16469
16470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16472 if (!SWIG_IsOK(res1)) {
16473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16474 }
16475 arg1 = reinterpret_cast< wxImage * >(argp1);
16476 {
16477 arg2 = wxString_in_helper(obj1);
16478 if (arg2 == NULL) SWIG_fail;
16479 temp2 = true;
16480 }
16481 ecode3 = SWIG_AsVal_int(obj2, &val3);
16482 if (!SWIG_IsOK(ecode3)) {
16483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16484 }
16485 arg3 = static_cast< int >(val3);
16486 {
16487 PyThreadState* __tstate = wxPyBeginAllowThreads();
16488 (arg1)->SetOption((wxString const &)*arg2,arg3);
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 resultobj = SWIG_Py_Void();
16493 {
16494 if (temp2)
16495 delete arg2;
16496 }
16497 return resultobj;
16498 fail:
16499 {
16500 if (temp2)
16501 delete arg2;
16502 }
16503 return NULL;
16504 }
16505
16506
16507 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16508 PyObject *resultobj = 0;
16509 wxImage *arg1 = (wxImage *) 0 ;
16510 wxString *arg2 = 0 ;
16511 wxString result;
16512 void *argp1 = 0 ;
16513 int res1 = 0 ;
16514 bool temp2 = false ;
16515 PyObject * obj0 = 0 ;
16516 PyObject * obj1 = 0 ;
16517 char * kwnames[] = {
16518 (char *) "self",(char *) "name", NULL
16519 };
16520
16521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16525 }
16526 arg1 = reinterpret_cast< wxImage * >(argp1);
16527 {
16528 arg2 = wxString_in_helper(obj1);
16529 if (arg2 == NULL) SWIG_fail;
16530 temp2 = true;
16531 }
16532 {
16533 PyThreadState* __tstate = wxPyBeginAllowThreads();
16534 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 {
16539 #if wxUSE_UNICODE
16540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16541 #else
16542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16543 #endif
16544 }
16545 {
16546 if (temp2)
16547 delete arg2;
16548 }
16549 return resultobj;
16550 fail:
16551 {
16552 if (temp2)
16553 delete arg2;
16554 }
16555 return NULL;
16556 }
16557
16558
16559 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16560 PyObject *resultobj = 0;
16561 wxImage *arg1 = (wxImage *) 0 ;
16562 wxString *arg2 = 0 ;
16563 int result;
16564 void *argp1 = 0 ;
16565 int res1 = 0 ;
16566 bool temp2 = false ;
16567 PyObject * obj0 = 0 ;
16568 PyObject * obj1 = 0 ;
16569 char * kwnames[] = {
16570 (char *) "self",(char *) "name", NULL
16571 };
16572
16573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",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_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16577 }
16578 arg1 = reinterpret_cast< wxImage * >(argp1);
16579 {
16580 arg2 = wxString_in_helper(obj1);
16581 if (arg2 == NULL) SWIG_fail;
16582 temp2 = true;
16583 }
16584 {
16585 PyThreadState* __tstate = wxPyBeginAllowThreads();
16586 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 resultobj = SWIG_From_int(static_cast< int >(result));
16591 {
16592 if (temp2)
16593 delete arg2;
16594 }
16595 return resultobj;
16596 fail:
16597 {
16598 if (temp2)
16599 delete arg2;
16600 }
16601 return NULL;
16602 }
16603
16604
16605 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj = 0;
16607 wxImage *arg1 = (wxImage *) 0 ;
16608 wxString *arg2 = 0 ;
16609 bool result;
16610 void *argp1 = 0 ;
16611 int res1 = 0 ;
16612 bool temp2 = false ;
16613 PyObject * obj0 = 0 ;
16614 PyObject * obj1 = 0 ;
16615 char * kwnames[] = {
16616 (char *) "self",(char *) "name", NULL
16617 };
16618
16619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16621 if (!SWIG_IsOK(res1)) {
16622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16623 }
16624 arg1 = reinterpret_cast< wxImage * >(argp1);
16625 {
16626 arg2 = wxString_in_helper(obj1);
16627 if (arg2 == NULL) SWIG_fail;
16628 temp2 = true;
16629 }
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 {
16637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16638 }
16639 {
16640 if (temp2)
16641 delete arg2;
16642 }
16643 return resultobj;
16644 fail:
16645 {
16646 if (temp2)
16647 delete arg2;
16648 }
16649 return NULL;
16650 }
16651
16652
16653 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16654 PyObject *resultobj = 0;
16655 wxImage *arg1 = (wxImage *) 0 ;
16656 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16657 unsigned long result;
16658 void *argp1 = 0 ;
16659 int res1 = 0 ;
16660 unsigned long val2 ;
16661 int ecode2 = 0 ;
16662 PyObject * obj0 = 0 ;
16663 PyObject * obj1 = 0 ;
16664 char * kwnames[] = {
16665 (char *) "self",(char *) "stopafter", NULL
16666 };
16667
16668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16670 if (!SWIG_IsOK(res1)) {
16671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16672 }
16673 arg1 = reinterpret_cast< wxImage * >(argp1);
16674 if (obj1) {
16675 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16676 if (!SWIG_IsOK(ecode2)) {
16677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16678 }
16679 arg2 = static_cast< unsigned long >(val2);
16680 }
16681 {
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = (unsigned long)(arg1)->CountColours(arg2);
16684 wxPyEndAllowThreads(__tstate);
16685 if (PyErr_Occurred()) SWIG_fail;
16686 }
16687 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj = 0;
16696 wxImage *arg1 = (wxImage *) 0 ;
16697 wxImageHistogram *arg2 = 0 ;
16698 unsigned long result;
16699 void *argp1 = 0 ;
16700 int res1 = 0 ;
16701 void *argp2 = 0 ;
16702 int res2 = 0 ;
16703 PyObject * obj0 = 0 ;
16704 PyObject * obj1 = 0 ;
16705 char * kwnames[] = {
16706 (char *) "self",(char *) "h", NULL
16707 };
16708
16709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16711 if (!SWIG_IsOK(res1)) {
16712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16713 }
16714 arg1 = reinterpret_cast< wxImage * >(argp1);
16715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16716 if (!SWIG_IsOK(res2)) {
16717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16718 }
16719 if (!argp2) {
16720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16721 }
16722 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16723 {
16724 PyThreadState* __tstate = wxPyBeginAllowThreads();
16725 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16726 wxPyEndAllowThreads(__tstate);
16727 if (PyErr_Occurred()) SWIG_fail;
16728 }
16729 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16730 return resultobj;
16731 fail:
16732 return NULL;
16733 }
16734
16735
16736 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16737 PyObject *resultobj = 0;
16738 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16739 void *argp1 = 0 ;
16740 int res1 = 0 ;
16741 PyObject * obj0 = 0 ;
16742 char * kwnames[] = {
16743 (char *) "handler", NULL
16744 };
16745
16746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16748 if (!SWIG_IsOK(res1)) {
16749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16750 }
16751 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 wxImage::AddHandler(arg1);
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 resultobj = SWIG_Py_Void();
16759 return resultobj;
16760 fail:
16761 return NULL;
16762 }
16763
16764
16765 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16766 PyObject *resultobj = 0;
16767 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16768 void *argp1 = 0 ;
16769 int res1 = 0 ;
16770 PyObject * obj0 = 0 ;
16771 char * kwnames[] = {
16772 (char *) "handler", NULL
16773 };
16774
16775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16777 if (!SWIG_IsOK(res1)) {
16778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16779 }
16780 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16781 {
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 wxImage::InsertHandler(arg1);
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 resultobj = SWIG_Py_Void();
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16795 PyObject *resultobj = 0;
16796 wxString *arg1 = 0 ;
16797 bool result;
16798 bool temp1 = false ;
16799 PyObject * obj0 = 0 ;
16800 char * kwnames[] = {
16801 (char *) "name", NULL
16802 };
16803
16804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16805 {
16806 arg1 = wxString_in_helper(obj0);
16807 if (arg1 == NULL) SWIG_fail;
16808 temp1 = true;
16809 }
16810 {
16811 PyThreadState* __tstate = wxPyBeginAllowThreads();
16812 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 {
16817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16818 }
16819 {
16820 if (temp1)
16821 delete arg1;
16822 }
16823 return resultobj;
16824 fail:
16825 {
16826 if (temp1)
16827 delete arg1;
16828 }
16829 return NULL;
16830 }
16831
16832
16833 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16834 PyObject *resultobj = 0;
16835 PyObject *result = 0 ;
16836
16837 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 result = (PyObject *)wxImage_GetHandlers();
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = result;
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16852 PyObject *resultobj = 0;
16853 wxString result;
16854
16855 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16856 {
16857 PyThreadState* __tstate = wxPyBeginAllowThreads();
16858 result = wxImage::GetImageExtWildcard();
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 {
16863 #if wxUSE_UNICODE
16864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16865 #else
16866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16867 #endif
16868 }
16869 return resultobj;
16870 fail:
16871 return NULL;
16872 }
16873
16874
16875 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16876 PyObject *resultobj = 0;
16877 wxImage *arg1 = (wxImage *) 0 ;
16878 int arg2 = (int) -1 ;
16879 wxBitmap result;
16880 void *argp1 = 0 ;
16881 int res1 = 0 ;
16882 int val2 ;
16883 int ecode2 = 0 ;
16884 PyObject * obj0 = 0 ;
16885 PyObject * obj1 = 0 ;
16886 char * kwnames[] = {
16887 (char *) "self",(char *) "depth", NULL
16888 };
16889
16890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16892 if (!SWIG_IsOK(res1)) {
16893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16894 }
16895 arg1 = reinterpret_cast< wxImage * >(argp1);
16896 if (obj1) {
16897 ecode2 = SWIG_AsVal_int(obj1, &val2);
16898 if (!SWIG_IsOK(ecode2)) {
16899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16900 }
16901 arg2 = static_cast< int >(val2);
16902 }
16903 {
16904 if (!wxPyCheckForApp()) SWIG_fail;
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = wxImage_ConvertToBitmap(arg1,arg2);
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj = 0;
16919 wxImage *arg1 = (wxImage *) 0 ;
16920 byte arg2 ;
16921 byte arg3 ;
16922 byte arg4 ;
16923 wxBitmap result;
16924 void *argp1 = 0 ;
16925 int res1 = 0 ;
16926 unsigned char val2 ;
16927 int ecode2 = 0 ;
16928 unsigned char val3 ;
16929 int ecode3 = 0 ;
16930 unsigned char val4 ;
16931 int ecode4 = 0 ;
16932 PyObject * obj0 = 0 ;
16933 PyObject * obj1 = 0 ;
16934 PyObject * obj2 = 0 ;
16935 PyObject * obj3 = 0 ;
16936 char * kwnames[] = {
16937 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16938 };
16939
16940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16942 if (!SWIG_IsOK(res1)) {
16943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16944 }
16945 arg1 = reinterpret_cast< wxImage * >(argp1);
16946 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16947 if (!SWIG_IsOK(ecode2)) {
16948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16949 }
16950 arg2 = static_cast< byte >(val2);
16951 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16952 if (!SWIG_IsOK(ecode3)) {
16953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16954 }
16955 arg3 = static_cast< byte >(val3);
16956 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16957 if (!SWIG_IsOK(ecode4)) {
16958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16959 }
16960 arg4 = static_cast< byte >(val4);
16961 {
16962 if (!wxPyCheckForApp()) SWIG_fail;
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16969 return resultobj;
16970 fail:
16971 return NULL;
16972 }
16973
16974
16975 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16976 PyObject *resultobj = 0;
16977 wxImage *arg1 = (wxImage *) 0 ;
16978 double arg2 ;
16979 void *argp1 = 0 ;
16980 int res1 = 0 ;
16981 double val2 ;
16982 int ecode2 = 0 ;
16983 PyObject * obj0 = 0 ;
16984 PyObject * obj1 = 0 ;
16985 char * kwnames[] = {
16986 (char *) "self",(char *) "angle", NULL
16987 };
16988
16989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16991 if (!SWIG_IsOK(res1)) {
16992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16993 }
16994 arg1 = reinterpret_cast< wxImage * >(argp1);
16995 ecode2 = SWIG_AsVal_double(obj1, &val2);
16996 if (!SWIG_IsOK(ecode2)) {
16997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16998 }
16999 arg2 = static_cast< double >(val2);
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 (arg1)->RotateHue(arg2);
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 resultobj = SWIG_Py_Void();
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj = 0;
17015 wxImage_RGBValue arg1 ;
17016 wxImage_HSVValue result;
17017 void *argp1 ;
17018 int res1 = 0 ;
17019 PyObject * obj0 = 0 ;
17020 char * kwnames[] = {
17021 (char *) "rgb", NULL
17022 };
17023
17024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17025 {
17026 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17027 if (!SWIG_IsOK(res1)) {
17028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17029 }
17030 if (!argp1) {
17031 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17032 } else {
17033 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17034 arg1 = *temp;
17035 if (SWIG_IsNewObj(res1)) delete temp;
17036 }
17037 }
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 result = wxImage::RGBtoHSV(arg1);
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj = 0;
17053 wxImage_HSVValue arg1 ;
17054 wxImage_RGBValue result;
17055 void *argp1 ;
17056 int res1 = 0 ;
17057 PyObject * obj0 = 0 ;
17058 char * kwnames[] = {
17059 (char *) "hsv", NULL
17060 };
17061
17062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17063 {
17064 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17065 if (!SWIG_IsOK(res1)) {
17066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17067 }
17068 if (!argp1) {
17069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17070 } else {
17071 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17072 arg1 = *temp;
17073 if (SWIG_IsNewObj(res1)) delete temp;
17074 }
17075 }
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = wxImage::HSVtoRGB(arg1);
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17090 PyObject *obj;
17091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17092 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17093 return SWIG_Py_Void();
17094 }
17095
17096 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17097 return SWIG_Python_InitShadowInstance(args);
17098 }
17099
17100 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17101 PyObject *resultobj = 0;
17102 int arg1 ;
17103 int arg2 ;
17104 buffer arg3 ;
17105 int arg4 ;
17106 buffer arg5 = (buffer) NULL ;
17107 int arg6 = (int) 0 ;
17108 wxImage *result = 0 ;
17109 int val1 ;
17110 int ecode1 = 0 ;
17111 int val2 ;
17112 int ecode2 = 0 ;
17113 Py_ssize_t temp3 ;
17114 Py_ssize_t temp5 ;
17115 PyObject * obj0 = 0 ;
17116 PyObject * obj1 = 0 ;
17117 PyObject * obj2 = 0 ;
17118 PyObject * obj3 = 0 ;
17119 char * kwnames[] = {
17120 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17121 };
17122
17123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17124 ecode1 = SWIG_AsVal_int(obj0, &val1);
17125 if (!SWIG_IsOK(ecode1)) {
17126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17127 }
17128 arg1 = static_cast< int >(val1);
17129 ecode2 = SWIG_AsVal_int(obj1, &val2);
17130 if (!SWIG_IsOK(ecode2)) {
17131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17132 }
17133 arg2 = static_cast< int >(val2);
17134 {
17135 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17136 arg4 = (int)temp3;
17137 }
17138 if (obj3) {
17139 {
17140 if (obj3 != Py_None) {
17141 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17142 arg6 = (int)temp5;
17143 }
17144 }
17145 }
17146 {
17147 PyThreadState* __tstate = wxPyBeginAllowThreads();
17148 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17149 wxPyEndAllowThreads(__tstate);
17150 if (PyErr_Occurred()) SWIG_fail;
17151 }
17152 {
17153 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17154 }
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 SWIGINTERN int NullImage_set(PyObject *) {
17162 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17163 return 1;
17164 }
17165
17166
17167 SWIGINTERN PyObject *NullImage_get(void) {
17168 PyObject *pyobj = 0;
17169
17170 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17171 return pyobj;
17172 }
17173
17174
17175 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17176 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17177 return 1;
17178 }
17179
17180
17181 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17182 PyObject *pyobj = 0;
17183
17184 {
17185 #if wxUSE_UNICODE
17186 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17187 #else
17188 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17189 #endif
17190 }
17191 return pyobj;
17192 }
17193
17194
17195 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17196 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17197 return 1;
17198 }
17199
17200
17201 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17202 PyObject *pyobj = 0;
17203
17204 {
17205 #if wxUSE_UNICODE
17206 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17207 #else
17208 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17209 #endif
17210 }
17211 return pyobj;
17212 }
17213
17214
17215 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17216 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17217 return 1;
17218 }
17219
17220
17221 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17222 PyObject *pyobj = 0;
17223
17224 {
17225 #if wxUSE_UNICODE
17226 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17227 #else
17228 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17229 #endif
17230 }
17231 return pyobj;
17232 }
17233
17234
17235 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17236 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17237 return 1;
17238 }
17239
17240
17241 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17242 PyObject *pyobj = 0;
17243
17244 {
17245 #if wxUSE_UNICODE
17246 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17247 #else
17248 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17249 #endif
17250 }
17251 return pyobj;
17252 }
17253
17254
17255 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17256 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17257 return 1;
17258 }
17259
17260
17261 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17262 PyObject *pyobj = 0;
17263
17264 {
17265 #if wxUSE_UNICODE
17266 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17267 #else
17268 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17269 #endif
17270 }
17271 return pyobj;
17272 }
17273
17274
17275 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17276 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17277 return 1;
17278 }
17279
17280
17281 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17282 PyObject *pyobj = 0;
17283
17284 {
17285 #if wxUSE_UNICODE
17286 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17287 #else
17288 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17289 #endif
17290 }
17291 return pyobj;
17292 }
17293
17294
17295 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17296 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17297 return 1;
17298 }
17299
17300
17301 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17302 PyObject *pyobj = 0;
17303
17304 {
17305 #if wxUSE_UNICODE
17306 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17307 #else
17308 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17309 #endif
17310 }
17311 return pyobj;
17312 }
17313
17314
17315 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17316 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17317 return 1;
17318 }
17319
17320
17321 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17322 PyObject *pyobj = 0;
17323
17324 {
17325 #if wxUSE_UNICODE
17326 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17327 #else
17328 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17329 #endif
17330 }
17331 return pyobj;
17332 }
17333
17334
17335 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17336 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17337 return 1;
17338 }
17339
17340
17341 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17342 PyObject *pyobj = 0;
17343
17344 {
17345 #if wxUSE_UNICODE
17346 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17347 #else
17348 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17349 #endif
17350 }
17351 return pyobj;
17352 }
17353
17354
17355 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17356 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17357 return 1;
17358 }
17359
17360
17361 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17362 PyObject *pyobj = 0;
17363
17364 {
17365 #if wxUSE_UNICODE
17366 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17367 #else
17368 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17369 #endif
17370 }
17371 return pyobj;
17372 }
17373
17374
17375 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17376 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17377 return 1;
17378 }
17379
17380
17381 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17382 PyObject *pyobj = 0;
17383
17384 {
17385 #if wxUSE_UNICODE
17386 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17387 #else
17388 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17389 #endif
17390 }
17391 return pyobj;
17392 }
17393
17394
17395 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17396 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17397 return 1;
17398 }
17399
17400
17401 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17402 PyObject *pyobj = 0;
17403
17404 {
17405 #if wxUSE_UNICODE
17406 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17407 #else
17408 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17409 #endif
17410 }
17411 return pyobj;
17412 }
17413
17414
17415 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17416 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17417 return 1;
17418 }
17419
17420
17421 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17422 PyObject *pyobj = 0;
17423
17424 {
17425 #if wxUSE_UNICODE
17426 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17427 #else
17428 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17429 #endif
17430 }
17431 return pyobj;
17432 }
17433
17434
17435 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17436 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17437 return 1;
17438 }
17439
17440
17441 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17442 PyObject *pyobj = 0;
17443
17444 {
17445 #if wxUSE_UNICODE
17446 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17447 #else
17448 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17449 #endif
17450 }
17451 return pyobj;
17452 }
17453
17454
17455 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17456 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17457 return 1;
17458 }
17459
17460
17461 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17462 PyObject *pyobj = 0;
17463
17464 {
17465 #if wxUSE_UNICODE
17466 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17467 #else
17468 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17469 #endif
17470 }
17471 return pyobj;
17472 }
17473
17474
17475 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 PyObject *resultobj = 0;
17477 wxBMPHandler *result = 0 ;
17478
17479 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (wxBMPHandler *)new wxBMPHandler();
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17487 return resultobj;
17488 fail:
17489 return NULL;
17490 }
17491
17492
17493 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 PyObject *obj;
17495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17496 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17497 return SWIG_Py_Void();
17498 }
17499
17500 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17501 return SWIG_Python_InitShadowInstance(args);
17502 }
17503
17504 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17505 PyObject *resultobj = 0;
17506 wxICOHandler *result = 0 ;
17507
17508 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (wxICOHandler *)new wxICOHandler();
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17523 PyObject *obj;
17524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17525 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17526 return SWIG_Py_Void();
17527 }
17528
17529 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17530 return SWIG_Python_InitShadowInstance(args);
17531 }
17532
17533 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17534 PyObject *resultobj = 0;
17535 wxCURHandler *result = 0 ;
17536
17537 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (wxCURHandler *)new wxCURHandler();
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17545 return resultobj;
17546 fail:
17547 return NULL;
17548 }
17549
17550
17551 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 PyObject *obj;
17553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17554 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17555 return SWIG_Py_Void();
17556 }
17557
17558 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559 return SWIG_Python_InitShadowInstance(args);
17560 }
17561
17562 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17563 PyObject *resultobj = 0;
17564 wxANIHandler *result = 0 ;
17565
17566 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17567 {
17568 PyThreadState* __tstate = wxPyBeginAllowThreads();
17569 result = (wxANIHandler *)new wxANIHandler();
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17574 return resultobj;
17575 fail:
17576 return NULL;
17577 }
17578
17579
17580 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 PyObject *obj;
17582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17583 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17584 return SWIG_Py_Void();
17585 }
17586
17587 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17588 return SWIG_Python_InitShadowInstance(args);
17589 }
17590
17591 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *resultobj = 0;
17593 wxPNGHandler *result = 0 ;
17594
17595 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17596 {
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (wxPNGHandler *)new wxPNGHandler();
17599 wxPyEndAllowThreads(__tstate);
17600 if (PyErr_Occurred()) SWIG_fail;
17601 }
17602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 PyObject *obj;
17611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17612 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17613 return SWIG_Py_Void();
17614 }
17615
17616 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17617 return SWIG_Python_InitShadowInstance(args);
17618 }
17619
17620 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *resultobj = 0;
17622 wxGIFHandler *result = 0 ;
17623
17624 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17625 {
17626 PyThreadState* __tstate = wxPyBeginAllowThreads();
17627 result = (wxGIFHandler *)new wxGIFHandler();
17628 wxPyEndAllowThreads(__tstate);
17629 if (PyErr_Occurred()) SWIG_fail;
17630 }
17631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17639 PyObject *obj;
17640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17641 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17642 return SWIG_Py_Void();
17643 }
17644
17645 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17646 return SWIG_Python_InitShadowInstance(args);
17647 }
17648
17649 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17650 PyObject *resultobj = 0;
17651 wxPCXHandler *result = 0 ;
17652
17653 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17654 {
17655 PyThreadState* __tstate = wxPyBeginAllowThreads();
17656 result = (wxPCXHandler *)new wxPCXHandler();
17657 wxPyEndAllowThreads(__tstate);
17658 if (PyErr_Occurred()) SWIG_fail;
17659 }
17660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17668 PyObject *obj;
17669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17671 return SWIG_Py_Void();
17672 }
17673
17674 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17675 return SWIG_Python_InitShadowInstance(args);
17676 }
17677
17678 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17679 PyObject *resultobj = 0;
17680 wxJPEGHandler *result = 0 ;
17681
17682 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = (wxJPEGHandler *)new wxJPEGHandler();
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17690 return resultobj;
17691 fail:
17692 return NULL;
17693 }
17694
17695
17696 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17697 PyObject *obj;
17698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17699 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17700 return SWIG_Py_Void();
17701 }
17702
17703 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17704 return SWIG_Python_InitShadowInstance(args);
17705 }
17706
17707 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17708 PyObject *resultobj = 0;
17709 wxPNMHandler *result = 0 ;
17710
17711 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17712 {
17713 PyThreadState* __tstate = wxPyBeginAllowThreads();
17714 result = (wxPNMHandler *)new wxPNMHandler();
17715 wxPyEndAllowThreads(__tstate);
17716 if (PyErr_Occurred()) SWIG_fail;
17717 }
17718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17719 return resultobj;
17720 fail:
17721 return NULL;
17722 }
17723
17724
17725 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17726 PyObject *obj;
17727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17728 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17729 return SWIG_Py_Void();
17730 }
17731
17732 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17733 return SWIG_Python_InitShadowInstance(args);
17734 }
17735
17736 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737 PyObject *resultobj = 0;
17738 wxXPMHandler *result = 0 ;
17739
17740 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17741 {
17742 PyThreadState* __tstate = wxPyBeginAllowThreads();
17743 result = (wxXPMHandler *)new wxXPMHandler();
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17748 return resultobj;
17749 fail:
17750 return NULL;
17751 }
17752
17753
17754 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17755 PyObject *obj;
17756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17757 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17758 return SWIG_Py_Void();
17759 }
17760
17761 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17762 return SWIG_Python_InitShadowInstance(args);
17763 }
17764
17765 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17766 PyObject *resultobj = 0;
17767 wxTIFFHandler *result = 0 ;
17768
17769 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17770 {
17771 PyThreadState* __tstate = wxPyBeginAllowThreads();
17772 result = (wxTIFFHandler *)new wxTIFFHandler();
17773 wxPyEndAllowThreads(__tstate);
17774 if (PyErr_Occurred()) SWIG_fail;
17775 }
17776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17777 return resultobj;
17778 fail:
17779 return NULL;
17780 }
17781
17782
17783 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17784 PyObject *obj;
17785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17786 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17787 return SWIG_Py_Void();
17788 }
17789
17790 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 return SWIG_Python_InitShadowInstance(args);
17792 }
17793
17794 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17795 PyObject *resultobj = 0;
17796 wxImage *arg1 = 0 ;
17797 wxImage *arg2 = 0 ;
17798 int arg3 = (int) 236 ;
17799 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17800 bool result;
17801 void *argp1 = 0 ;
17802 int res1 = 0 ;
17803 void *argp2 = 0 ;
17804 int res2 = 0 ;
17805 int val3 ;
17806 int ecode3 = 0 ;
17807 int val4 ;
17808 int ecode4 = 0 ;
17809 PyObject * obj0 = 0 ;
17810 PyObject * obj1 = 0 ;
17811 PyObject * obj2 = 0 ;
17812 PyObject * obj3 = 0 ;
17813 char * kwnames[] = {
17814 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17815 };
17816
17817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17818 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17819 if (!SWIG_IsOK(res1)) {
17820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17821 }
17822 if (!argp1) {
17823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17824 }
17825 arg1 = reinterpret_cast< wxImage * >(argp1);
17826 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17827 if (!SWIG_IsOK(res2)) {
17828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17829 }
17830 if (!argp2) {
17831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17832 }
17833 arg2 = reinterpret_cast< wxImage * >(argp2);
17834 if (obj2) {
17835 ecode3 = SWIG_AsVal_int(obj2, &val3);
17836 if (!SWIG_IsOK(ecode3)) {
17837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17838 }
17839 arg3 = static_cast< int >(val3);
17840 }
17841 if (obj3) {
17842 ecode4 = SWIG_AsVal_int(obj3, &val4);
17843 if (!SWIG_IsOK(ecode4)) {
17844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17845 }
17846 arg4 = static_cast< int >(val4);
17847 }
17848 {
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17851 wxPyEndAllowThreads(__tstate);
17852 if (PyErr_Occurred()) SWIG_fail;
17853 }
17854 {
17855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17856 }
17857 return resultobj;
17858 fail:
17859 return NULL;
17860 }
17861
17862
17863 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17864 PyObject *obj;
17865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17866 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17867 return SWIG_Py_Void();
17868 }
17869
17870 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17871 PyObject *resultobj = 0;
17872 wxEvtHandler *result = 0 ;
17873
17874 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17875 {
17876 PyThreadState* __tstate = wxPyBeginAllowThreads();
17877 result = (wxEvtHandler *)new wxEvtHandler();
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17889 PyObject *resultobj = 0;
17890 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17891 wxEvtHandler *result = 0 ;
17892 void *argp1 = 0 ;
17893 int res1 = 0 ;
17894 PyObject *swig_obj[1] ;
17895
17896 if (!args) SWIG_fail;
17897 swig_obj[0] = args;
17898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17899 if (!SWIG_IsOK(res1)) {
17900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17901 }
17902 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17903 {
17904 PyThreadState* __tstate = wxPyBeginAllowThreads();
17905 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17906 wxPyEndAllowThreads(__tstate);
17907 if (PyErr_Occurred()) SWIG_fail;
17908 }
17909 {
17910 resultobj = wxPyMake_wxObject(result, 0);
17911 }
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17919 PyObject *resultobj = 0;
17920 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17921 wxEvtHandler *result = 0 ;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 PyObject *swig_obj[1] ;
17925
17926 if (!args) SWIG_fail;
17927 swig_obj[0] = args;
17928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17931 }
17932 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 resultobj = wxPyMake_wxObject(result, 0);
17941 }
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17949 PyObject *resultobj = 0;
17950 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17951 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17952 void *argp1 = 0 ;
17953 int res1 = 0 ;
17954 void *argp2 = 0 ;
17955 int res2 = 0 ;
17956 PyObject * obj0 = 0 ;
17957 PyObject * obj1 = 0 ;
17958 char * kwnames[] = {
17959 (char *) "self",(char *) "handler", NULL
17960 };
17961
17962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17964 if (!SWIG_IsOK(res1)) {
17965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17966 }
17967 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17968 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17969 if (!SWIG_IsOK(res2)) {
17970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17971 }
17972 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17973 {
17974 PyThreadState* __tstate = wxPyBeginAllowThreads();
17975 (arg1)->SetNextHandler(arg2);
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 resultobj = SWIG_Py_Void();
17980 return resultobj;
17981 fail:
17982 return NULL;
17983 }
17984
17985
17986 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17987 PyObject *resultobj = 0;
17988 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17989 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17990 void *argp1 = 0 ;
17991 int res1 = 0 ;
17992 void *argp2 = 0 ;
17993 int res2 = 0 ;
17994 PyObject * obj0 = 0 ;
17995 PyObject * obj1 = 0 ;
17996 char * kwnames[] = {
17997 (char *) "self",(char *) "handler", NULL
17998 };
17999
18000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18002 if (!SWIG_IsOK(res1)) {
18003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18004 }
18005 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18006 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18007 if (!SWIG_IsOK(res2)) {
18008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18009 }
18010 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18011 {
18012 PyThreadState* __tstate = wxPyBeginAllowThreads();
18013 (arg1)->SetPreviousHandler(arg2);
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 resultobj = SWIG_Py_Void();
18018 return resultobj;
18019 fail:
18020 return NULL;
18021 }
18022
18023
18024 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18025 PyObject *resultobj = 0;
18026 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18027 bool result;
18028 void *argp1 = 0 ;
18029 int res1 = 0 ;
18030 PyObject *swig_obj[1] ;
18031
18032 if (!args) SWIG_fail;
18033 swig_obj[0] = args;
18034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18035 if (!SWIG_IsOK(res1)) {
18036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18037 }
18038 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18039 {
18040 PyThreadState* __tstate = wxPyBeginAllowThreads();
18041 result = (bool)(arg1)->GetEvtHandlerEnabled();
18042 wxPyEndAllowThreads(__tstate);
18043 if (PyErr_Occurred()) SWIG_fail;
18044 }
18045 {
18046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18047 }
18048 return resultobj;
18049 fail:
18050 return NULL;
18051 }
18052
18053
18054 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18055 PyObject *resultobj = 0;
18056 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18057 bool arg2 ;
18058 void *argp1 = 0 ;
18059 int res1 = 0 ;
18060 bool val2 ;
18061 int ecode2 = 0 ;
18062 PyObject * obj0 = 0 ;
18063 PyObject * obj1 = 0 ;
18064 char * kwnames[] = {
18065 (char *) "self",(char *) "enabled", NULL
18066 };
18067
18068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18070 if (!SWIG_IsOK(res1)) {
18071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18072 }
18073 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18074 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18075 if (!SWIG_IsOK(ecode2)) {
18076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18077 }
18078 arg2 = static_cast< bool >(val2);
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 (arg1)->SetEvtHandlerEnabled(arg2);
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 resultobj = SWIG_Py_Void();
18086 return resultobj;
18087 fail:
18088 return NULL;
18089 }
18090
18091
18092 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18093 PyObject *resultobj = 0;
18094 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18095 wxEvent *arg2 = 0 ;
18096 bool result;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 void *argp2 = 0 ;
18100 int res2 = 0 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 char * kwnames[] = {
18104 (char *) "self",(char *) "event", NULL
18105 };
18106
18107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18109 if (!SWIG_IsOK(res1)) {
18110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18111 }
18112 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18114 if (!SWIG_IsOK(res2)) {
18115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18116 }
18117 if (!argp2) {
18118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18119 }
18120 arg2 = reinterpret_cast< wxEvent * >(argp2);
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = (bool)(arg1)->ProcessEvent(*arg2);
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 {
18128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18129 }
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj = 0;
18138 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18139 wxEvent *arg2 = 0 ;
18140 void *argp1 = 0 ;
18141 int res1 = 0 ;
18142 void *argp2 = 0 ;
18143 int res2 = 0 ;
18144 PyObject * obj0 = 0 ;
18145 PyObject * obj1 = 0 ;
18146 char * kwnames[] = {
18147 (char *) "self",(char *) "event", NULL
18148 };
18149
18150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18152 if (!SWIG_IsOK(res1)) {
18153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18154 }
18155 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18157 if (!SWIG_IsOK(res2)) {
18158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18159 }
18160 if (!argp2) {
18161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18162 }
18163 arg2 = reinterpret_cast< wxEvent * >(argp2);
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 (arg1)->AddPendingEvent(*arg2);
18167 wxPyEndAllowThreads(__tstate);
18168 if (PyErr_Occurred()) SWIG_fail;
18169 }
18170 resultobj = SWIG_Py_Void();
18171 return resultobj;
18172 fail:
18173 return NULL;
18174 }
18175
18176
18177 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18178 PyObject *resultobj = 0;
18179 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18180 void *argp1 = 0 ;
18181 int res1 = 0 ;
18182 PyObject *swig_obj[1] ;
18183
18184 if (!args) SWIG_fail;
18185 swig_obj[0] = args;
18186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18187 if (!SWIG_IsOK(res1)) {
18188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18189 }
18190 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18191 {
18192 PyThreadState* __tstate = wxPyBeginAllowThreads();
18193 (arg1)->ProcessPendingEvents();
18194 wxPyEndAllowThreads(__tstate);
18195 if (PyErr_Occurred()) SWIG_fail;
18196 }
18197 resultobj = SWIG_Py_Void();
18198 return resultobj;
18199 fail:
18200 return NULL;
18201 }
18202
18203
18204 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18205 PyObject *resultobj = 0;
18206 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18207 int arg2 ;
18208 int arg3 ;
18209 int arg4 ;
18210 PyObject *arg5 = (PyObject *) 0 ;
18211 void *argp1 = 0 ;
18212 int res1 = 0 ;
18213 int val2 ;
18214 int ecode2 = 0 ;
18215 int val3 ;
18216 int ecode3 = 0 ;
18217 int val4 ;
18218 int ecode4 = 0 ;
18219 PyObject * obj0 = 0 ;
18220 PyObject * obj1 = 0 ;
18221 PyObject * obj2 = 0 ;
18222 PyObject * obj3 = 0 ;
18223 PyObject * obj4 = 0 ;
18224 char * kwnames[] = {
18225 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18226 };
18227
18228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18230 if (!SWIG_IsOK(res1)) {
18231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18232 }
18233 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18234 ecode2 = SWIG_AsVal_int(obj1, &val2);
18235 if (!SWIG_IsOK(ecode2)) {
18236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18237 }
18238 arg2 = static_cast< int >(val2);
18239 ecode3 = SWIG_AsVal_int(obj2, &val3);
18240 if (!SWIG_IsOK(ecode3)) {
18241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18242 }
18243 arg3 = static_cast< int >(val3);
18244 ecode4 = SWIG_AsVal_int(obj3, &val4);
18245 if (!SWIG_IsOK(ecode4)) {
18246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18247 }
18248 arg4 = static_cast< int >(val4);
18249 arg5 = obj4;
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 resultobj = SWIG_Py_Void();
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj = 0;
18265 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18266 int arg2 ;
18267 int arg3 = (int) -1 ;
18268 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18269 bool result;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 int val2 ;
18273 int ecode2 = 0 ;
18274 int val3 ;
18275 int ecode3 = 0 ;
18276 int val4 ;
18277 int ecode4 = 0 ;
18278 PyObject * obj0 = 0 ;
18279 PyObject * obj1 = 0 ;
18280 PyObject * obj2 = 0 ;
18281 PyObject * obj3 = 0 ;
18282 char * kwnames[] = {
18283 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18284 };
18285
18286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18288 if (!SWIG_IsOK(res1)) {
18289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18290 }
18291 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18292 ecode2 = SWIG_AsVal_int(obj1, &val2);
18293 if (!SWIG_IsOK(ecode2)) {
18294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18295 }
18296 arg2 = static_cast< int >(val2);
18297 if (obj2) {
18298 ecode3 = SWIG_AsVal_int(obj2, &val3);
18299 if (!SWIG_IsOK(ecode3)) {
18300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18301 }
18302 arg3 = static_cast< int >(val3);
18303 }
18304 if (obj3) {
18305 ecode4 = SWIG_AsVal_int(obj3, &val4);
18306 if (!SWIG_IsOK(ecode4)) {
18307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18308 }
18309 arg4 = static_cast< wxEventType >(val4);
18310 }
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18314 wxPyEndAllowThreads(__tstate);
18315 if (PyErr_Occurred()) SWIG_fail;
18316 }
18317 {
18318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18319 }
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj = 0;
18328 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18329 PyObject *arg2 = (PyObject *) 0 ;
18330 bool arg3 = (bool) true ;
18331 void *argp1 = 0 ;
18332 int res1 = 0 ;
18333 bool val3 ;
18334 int ecode3 = 0 ;
18335 PyObject * obj0 = 0 ;
18336 PyObject * obj1 = 0 ;
18337 PyObject * obj2 = 0 ;
18338 char * kwnames[] = {
18339 (char *) "self",(char *) "_self",(char *) "incref", NULL
18340 };
18341
18342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18344 if (!SWIG_IsOK(res1)) {
18345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18346 }
18347 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18348 arg2 = obj1;
18349 if (obj2) {
18350 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18351 if (!SWIG_IsOK(ecode3)) {
18352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18353 }
18354 arg3 = static_cast< bool >(val3);
18355 }
18356 {
18357 PyThreadState* __tstate = wxPyBeginAllowThreads();
18358 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18359 wxPyEndAllowThreads(__tstate);
18360 if (PyErr_Occurred()) SWIG_fail;
18361 }
18362 resultobj = SWIG_Py_Void();
18363 return resultobj;
18364 fail:
18365 return NULL;
18366 }
18367
18368
18369 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18370 PyObject *obj;
18371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18372 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18373 return SWIG_Py_Void();
18374 }
18375
18376 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18377 return SWIG_Python_InitShadowInstance(args);
18378 }
18379
18380 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18381 PyObject *resultobj = 0;
18382 wxEventType result;
18383
18384 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 result = (wxEventType)wxNewEventType();
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 resultobj = SWIG_From_int(static_cast< int >(result));
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18399 PyObject *resultobj = 0;
18400 wxEvent *arg1 = (wxEvent *) 0 ;
18401 void *argp1 = 0 ;
18402 int res1 = 0 ;
18403 PyObject *swig_obj[1] ;
18404
18405 if (!args) SWIG_fail;
18406 swig_obj[0] = args;
18407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18408 if (!SWIG_IsOK(res1)) {
18409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18410 }
18411 arg1 = reinterpret_cast< wxEvent * >(argp1);
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 delete arg1;
18415
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_Py_Void();
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18427 PyObject *resultobj = 0;
18428 wxEvent *arg1 = (wxEvent *) 0 ;
18429 wxEventType arg2 ;
18430 void *argp1 = 0 ;
18431 int res1 = 0 ;
18432 int val2 ;
18433 int ecode2 = 0 ;
18434 PyObject * obj0 = 0 ;
18435 PyObject * obj1 = 0 ;
18436 char * kwnames[] = {
18437 (char *) "self",(char *) "typ", NULL
18438 };
18439
18440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 ecode2 = SWIG_AsVal_int(obj1, &val2);
18447 if (!SWIG_IsOK(ecode2)) {
18448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18449 }
18450 arg2 = static_cast< wxEventType >(val2);
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 (arg1)->SetEventType(arg2);
18454 wxPyEndAllowThreads(__tstate);
18455 if (PyErr_Occurred()) SWIG_fail;
18456 }
18457 resultobj = SWIG_Py_Void();
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18465 PyObject *resultobj = 0;
18466 wxEvent *arg1 = (wxEvent *) 0 ;
18467 wxEventType result;
18468 void *argp1 = 0 ;
18469 int res1 = 0 ;
18470 PyObject *swig_obj[1] ;
18471
18472 if (!args) SWIG_fail;
18473 swig_obj[0] = args;
18474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18475 if (!SWIG_IsOK(res1)) {
18476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18477 }
18478 arg1 = reinterpret_cast< wxEvent * >(argp1);
18479 {
18480 PyThreadState* __tstate = wxPyBeginAllowThreads();
18481 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 resultobj = SWIG_From_int(static_cast< int >(result));
18486 return resultobj;
18487 fail:
18488 return NULL;
18489 }
18490
18491
18492 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18493 PyObject *resultobj = 0;
18494 wxEvent *arg1 = (wxEvent *) 0 ;
18495 wxObject *result = 0 ;
18496 void *argp1 = 0 ;
18497 int res1 = 0 ;
18498 PyObject *swig_obj[1] ;
18499
18500 if (!args) SWIG_fail;
18501 swig_obj[0] = args;
18502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18503 if (!SWIG_IsOK(res1)) {
18504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18505 }
18506 arg1 = reinterpret_cast< wxEvent * >(argp1);
18507 {
18508 PyThreadState* __tstate = wxPyBeginAllowThreads();
18509 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18510 wxPyEndAllowThreads(__tstate);
18511 if (PyErr_Occurred()) SWIG_fail;
18512 }
18513 {
18514 resultobj = wxPyMake_wxObject(result, (bool)0);
18515 }
18516 return resultobj;
18517 fail:
18518 return NULL;
18519 }
18520
18521
18522 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj = 0;
18524 wxEvent *arg1 = (wxEvent *) 0 ;
18525 wxObject *arg2 = (wxObject *) 0 ;
18526 void *argp1 = 0 ;
18527 int res1 = 0 ;
18528 void *argp2 = 0 ;
18529 int res2 = 0 ;
18530 PyObject * obj0 = 0 ;
18531 PyObject * obj1 = 0 ;
18532 char * kwnames[] = {
18533 (char *) "self",(char *) "obj", NULL
18534 };
18535
18536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18538 if (!SWIG_IsOK(res1)) {
18539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18540 }
18541 arg1 = reinterpret_cast< wxEvent * >(argp1);
18542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18543 if (!SWIG_IsOK(res2)) {
18544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18545 }
18546 arg2 = reinterpret_cast< wxObject * >(argp2);
18547 {
18548 PyThreadState* __tstate = wxPyBeginAllowThreads();
18549 (arg1)->SetEventObject(arg2);
18550 wxPyEndAllowThreads(__tstate);
18551 if (PyErr_Occurred()) SWIG_fail;
18552 }
18553 resultobj = SWIG_Py_Void();
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18561 PyObject *resultobj = 0;
18562 wxEvent *arg1 = (wxEvent *) 0 ;
18563 long result;
18564 void *argp1 = 0 ;
18565 int res1 = 0 ;
18566 PyObject *swig_obj[1] ;
18567
18568 if (!args) SWIG_fail;
18569 swig_obj[0] = args;
18570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18571 if (!SWIG_IsOK(res1)) {
18572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18573 }
18574 arg1 = reinterpret_cast< wxEvent * >(argp1);
18575 {
18576 PyThreadState* __tstate = wxPyBeginAllowThreads();
18577 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18578 wxPyEndAllowThreads(__tstate);
18579 if (PyErr_Occurred()) SWIG_fail;
18580 }
18581 resultobj = SWIG_From_long(static_cast< long >(result));
18582 return resultobj;
18583 fail:
18584 return NULL;
18585 }
18586
18587
18588 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj = 0;
18590 wxEvent *arg1 = (wxEvent *) 0 ;
18591 long arg2 = (long) 0 ;
18592 void *argp1 = 0 ;
18593 int res1 = 0 ;
18594 long val2 ;
18595 int ecode2 = 0 ;
18596 PyObject * obj0 = 0 ;
18597 PyObject * obj1 = 0 ;
18598 char * kwnames[] = {
18599 (char *) "self",(char *) "ts", NULL
18600 };
18601
18602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18604 if (!SWIG_IsOK(res1)) {
18605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18606 }
18607 arg1 = reinterpret_cast< wxEvent * >(argp1);
18608 if (obj1) {
18609 ecode2 = SWIG_AsVal_long(obj1, &val2);
18610 if (!SWIG_IsOK(ecode2)) {
18611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18612 }
18613 arg2 = static_cast< long >(val2);
18614 }
18615 {
18616 PyThreadState* __tstate = wxPyBeginAllowThreads();
18617 (arg1)->SetTimestamp(arg2);
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 resultobj = SWIG_Py_Void();
18622 return resultobj;
18623 fail:
18624 return NULL;
18625 }
18626
18627
18628 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18629 PyObject *resultobj = 0;
18630 wxEvent *arg1 = (wxEvent *) 0 ;
18631 int result;
18632 void *argp1 = 0 ;
18633 int res1 = 0 ;
18634 PyObject *swig_obj[1] ;
18635
18636 if (!args) SWIG_fail;
18637 swig_obj[0] = args;
18638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18639 if (!SWIG_IsOK(res1)) {
18640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18641 }
18642 arg1 = reinterpret_cast< wxEvent * >(argp1);
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 result = (int)((wxEvent const *)arg1)->GetId();
18646 wxPyEndAllowThreads(__tstate);
18647 if (PyErr_Occurred()) SWIG_fail;
18648 }
18649 resultobj = SWIG_From_int(static_cast< int >(result));
18650 return resultobj;
18651 fail:
18652 return NULL;
18653 }
18654
18655
18656 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18657 PyObject *resultobj = 0;
18658 wxEvent *arg1 = (wxEvent *) 0 ;
18659 int arg2 ;
18660 void *argp1 = 0 ;
18661 int res1 = 0 ;
18662 int val2 ;
18663 int ecode2 = 0 ;
18664 PyObject * obj0 = 0 ;
18665 PyObject * obj1 = 0 ;
18666 char * kwnames[] = {
18667 (char *) "self",(char *) "Id", NULL
18668 };
18669
18670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18672 if (!SWIG_IsOK(res1)) {
18673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18674 }
18675 arg1 = reinterpret_cast< wxEvent * >(argp1);
18676 ecode2 = SWIG_AsVal_int(obj1, &val2);
18677 if (!SWIG_IsOK(ecode2)) {
18678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18679 }
18680 arg2 = static_cast< int >(val2);
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 (arg1)->SetId(arg2);
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 resultobj = SWIG_Py_Void();
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18695 PyObject *resultobj = 0;
18696 wxEvent *arg1 = (wxEvent *) 0 ;
18697 bool result;
18698 void *argp1 = 0 ;
18699 int res1 = 0 ;
18700 PyObject *swig_obj[1] ;
18701
18702 if (!args) SWIG_fail;
18703 swig_obj[0] = args;
18704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18705 if (!SWIG_IsOK(res1)) {
18706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18707 }
18708 arg1 = reinterpret_cast< wxEvent * >(argp1);
18709 {
18710 PyThreadState* __tstate = wxPyBeginAllowThreads();
18711 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18712 wxPyEndAllowThreads(__tstate);
18713 if (PyErr_Occurred()) SWIG_fail;
18714 }
18715 {
18716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18717 }
18718 return resultobj;
18719 fail:
18720 return NULL;
18721 }
18722
18723
18724 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18725 PyObject *resultobj = 0;
18726 wxEvent *arg1 = (wxEvent *) 0 ;
18727 bool arg2 = (bool) true ;
18728 void *argp1 = 0 ;
18729 int res1 = 0 ;
18730 bool val2 ;
18731 int ecode2 = 0 ;
18732 PyObject * obj0 = 0 ;
18733 PyObject * obj1 = 0 ;
18734 char * kwnames[] = {
18735 (char *) "self",(char *) "skip", NULL
18736 };
18737
18738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18740 if (!SWIG_IsOK(res1)) {
18741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18742 }
18743 arg1 = reinterpret_cast< wxEvent * >(argp1);
18744 if (obj1) {
18745 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18746 if (!SWIG_IsOK(ecode2)) {
18747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18748 }
18749 arg2 = static_cast< bool >(val2);
18750 }
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 (arg1)->Skip(arg2);
18754 wxPyEndAllowThreads(__tstate);
18755 if (PyErr_Occurred()) SWIG_fail;
18756 }
18757 resultobj = SWIG_Py_Void();
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18765 PyObject *resultobj = 0;
18766 wxEvent *arg1 = (wxEvent *) 0 ;
18767 bool result;
18768 void *argp1 = 0 ;
18769 int res1 = 0 ;
18770 PyObject *swig_obj[1] ;
18771
18772 if (!args) SWIG_fail;
18773 swig_obj[0] = args;
18774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18775 if (!SWIG_IsOK(res1)) {
18776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18777 }
18778 arg1 = reinterpret_cast< wxEvent * >(argp1);
18779 {
18780 PyThreadState* __tstate = wxPyBeginAllowThreads();
18781 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18782 wxPyEndAllowThreads(__tstate);
18783 if (PyErr_Occurred()) SWIG_fail;
18784 }
18785 {
18786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18787 }
18788 return resultobj;
18789 fail:
18790 return NULL;
18791 }
18792
18793
18794 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18795 PyObject *resultobj = 0;
18796 wxEvent *arg1 = (wxEvent *) 0 ;
18797 bool result;
18798 void *argp1 = 0 ;
18799 int res1 = 0 ;
18800 PyObject *swig_obj[1] ;
18801
18802 if (!args) SWIG_fail;
18803 swig_obj[0] = args;
18804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18805 if (!SWIG_IsOK(res1)) {
18806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18807 }
18808 arg1 = reinterpret_cast< wxEvent * >(argp1);
18809 {
18810 PyThreadState* __tstate = wxPyBeginAllowThreads();
18811 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18812 wxPyEndAllowThreads(__tstate);
18813 if (PyErr_Occurred()) SWIG_fail;
18814 }
18815 {
18816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18817 }
18818 return resultobj;
18819 fail:
18820 return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *resultobj = 0;
18826 wxEvent *arg1 = (wxEvent *) 0 ;
18827 int result;
18828 void *argp1 = 0 ;
18829 int res1 = 0 ;
18830 PyObject *swig_obj[1] ;
18831
18832 if (!args) SWIG_fail;
18833 swig_obj[0] = args;
18834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18835 if (!SWIG_IsOK(res1)) {
18836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18837 }
18838 arg1 = reinterpret_cast< wxEvent * >(argp1);
18839 {
18840 PyThreadState* __tstate = wxPyBeginAllowThreads();
18841 result = (int)(arg1)->StopPropagation();
18842 wxPyEndAllowThreads(__tstate);
18843 if (PyErr_Occurred()) SWIG_fail;
18844 }
18845 resultobj = SWIG_From_int(static_cast< int >(result));
18846 return resultobj;
18847 fail:
18848 return NULL;
18849 }
18850
18851
18852 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18853 PyObject *resultobj = 0;
18854 wxEvent *arg1 = (wxEvent *) 0 ;
18855 int arg2 ;
18856 void *argp1 = 0 ;
18857 int res1 = 0 ;
18858 int val2 ;
18859 int ecode2 = 0 ;
18860 PyObject * obj0 = 0 ;
18861 PyObject * obj1 = 0 ;
18862 char * kwnames[] = {
18863 (char *) "self",(char *) "propagationLevel", NULL
18864 };
18865
18866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18868 if (!SWIG_IsOK(res1)) {
18869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18870 }
18871 arg1 = reinterpret_cast< wxEvent * >(argp1);
18872 ecode2 = SWIG_AsVal_int(obj1, &val2);
18873 if (!SWIG_IsOK(ecode2)) {
18874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18875 }
18876 arg2 = static_cast< int >(val2);
18877 {
18878 PyThreadState* __tstate = wxPyBeginAllowThreads();
18879 (arg1)->ResumePropagation(arg2);
18880 wxPyEndAllowThreads(__tstate);
18881 if (PyErr_Occurred()) SWIG_fail;
18882 }
18883 resultobj = SWIG_Py_Void();
18884 return resultobj;
18885 fail:
18886 return NULL;
18887 }
18888
18889
18890 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18891 PyObject *resultobj = 0;
18892 wxEvent *arg1 = (wxEvent *) 0 ;
18893 wxEvent *result = 0 ;
18894 void *argp1 = 0 ;
18895 int res1 = 0 ;
18896 PyObject *swig_obj[1] ;
18897
18898 if (!args) SWIG_fail;
18899 swig_obj[0] = args;
18900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18901 if (!SWIG_IsOK(res1)) {
18902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18903 }
18904 arg1 = reinterpret_cast< wxEvent * >(argp1);
18905 {
18906 PyThreadState* __tstate = wxPyBeginAllowThreads();
18907 result = (wxEvent *)(arg1)->Clone();
18908 wxPyEndAllowThreads(__tstate);
18909 if (PyErr_Occurred()) SWIG_fail;
18910 }
18911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18912 return resultobj;
18913 fail:
18914 return NULL;
18915 }
18916
18917
18918 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18919 PyObject *obj;
18920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18921 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18922 return SWIG_Py_Void();
18923 }
18924
18925 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = 0;
18927 wxEvent *arg1 = 0 ;
18928 wxPropagationDisabler *result = 0 ;
18929 void *argp1 = 0 ;
18930 int res1 = 0 ;
18931 PyObject * obj0 = 0 ;
18932 char * kwnames[] = {
18933 (char *) "event", NULL
18934 };
18935
18936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18937 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18938 if (!SWIG_IsOK(res1)) {
18939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18940 }
18941 if (!argp1) {
18942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18943 }
18944 arg1 = reinterpret_cast< wxEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18959 PyObject *resultobj = 0;
18960 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18961 void *argp1 = 0 ;
18962 int res1 = 0 ;
18963 PyObject *swig_obj[1] ;
18964
18965 if (!args) SWIG_fail;
18966 swig_obj[0] = args;
18967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18968 if (!SWIG_IsOK(res1)) {
18969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18970 }
18971 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 delete arg1;
18975
18976 wxPyEndAllowThreads(__tstate);
18977 if (PyErr_Occurred()) SWIG_fail;
18978 }
18979 resultobj = SWIG_Py_Void();
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18987 PyObject *obj;
18988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18989 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18990 return SWIG_Py_Void();
18991 }
18992
18993 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18994 return SWIG_Python_InitShadowInstance(args);
18995 }
18996
18997 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj = 0;
18999 wxEvent *arg1 = 0 ;
19000 wxPropagateOnce *result = 0 ;
19001 void *argp1 = 0 ;
19002 int res1 = 0 ;
19003 PyObject * obj0 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "event", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19009 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19012 }
19013 if (!argp1) {
19014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19015 }
19016 arg1 = reinterpret_cast< wxEvent * >(argp1);
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19031 PyObject *resultobj = 0;
19032 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19033 void *argp1 = 0 ;
19034 int res1 = 0 ;
19035 PyObject *swig_obj[1] ;
19036
19037 if (!args) SWIG_fail;
19038 swig_obj[0] = args;
19039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19040 if (!SWIG_IsOK(res1)) {
19041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19042 }
19043 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19044 {
19045 PyThreadState* __tstate = wxPyBeginAllowThreads();
19046 delete arg1;
19047
19048 wxPyEndAllowThreads(__tstate);
19049 if (PyErr_Occurred()) SWIG_fail;
19050 }
19051 resultobj = SWIG_Py_Void();
19052 return resultobj;
19053 fail:
19054 return NULL;
19055 }
19056
19057
19058 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19059 PyObject *obj;
19060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19061 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19062 return SWIG_Py_Void();
19063 }
19064
19065 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19066 return SWIG_Python_InitShadowInstance(args);
19067 }
19068
19069 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19070 PyObject *resultobj = 0;
19071 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19072 int arg2 = (int) 0 ;
19073 wxCommandEvent *result = 0 ;
19074 int val1 ;
19075 int ecode1 = 0 ;
19076 int val2 ;
19077 int ecode2 = 0 ;
19078 PyObject * obj0 = 0 ;
19079 PyObject * obj1 = 0 ;
19080 char * kwnames[] = {
19081 (char *) "commandType",(char *) "winid", NULL
19082 };
19083
19084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19085 if (obj0) {
19086 ecode1 = SWIG_AsVal_int(obj0, &val1);
19087 if (!SWIG_IsOK(ecode1)) {
19088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19089 }
19090 arg1 = static_cast< wxEventType >(val1);
19091 }
19092 if (obj1) {
19093 ecode2 = SWIG_AsVal_int(obj1, &val2);
19094 if (!SWIG_IsOK(ecode2)) {
19095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19096 }
19097 arg2 = static_cast< int >(val2);
19098 }
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19113 PyObject *resultobj = 0;
19114 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19115 int result;
19116 void *argp1 = 0 ;
19117 int res1 = 0 ;
19118 PyObject *swig_obj[1] ;
19119
19120 if (!args) SWIG_fail;
19121 swig_obj[0] = args;
19122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19123 if (!SWIG_IsOK(res1)) {
19124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19125 }
19126 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19127 {
19128 PyThreadState* __tstate = wxPyBeginAllowThreads();
19129 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19130 wxPyEndAllowThreads(__tstate);
19131 if (PyErr_Occurred()) SWIG_fail;
19132 }
19133 resultobj = SWIG_From_int(static_cast< int >(result));
19134 return resultobj;
19135 fail:
19136 return NULL;
19137 }
19138
19139
19140 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj = 0;
19142 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19143 wxString *arg2 = 0 ;
19144 void *argp1 = 0 ;
19145 int res1 = 0 ;
19146 bool temp2 = false ;
19147 PyObject * obj0 = 0 ;
19148 PyObject * obj1 = 0 ;
19149 char * kwnames[] = {
19150 (char *) "self",(char *) "s", NULL
19151 };
19152
19153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19155 if (!SWIG_IsOK(res1)) {
19156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19157 }
19158 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19159 {
19160 arg2 = wxString_in_helper(obj1);
19161 if (arg2 == NULL) SWIG_fail;
19162 temp2 = true;
19163 }
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 (arg1)->SetString((wxString const &)*arg2);
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 resultobj = SWIG_Py_Void();
19171 {
19172 if (temp2)
19173 delete arg2;
19174 }
19175 return resultobj;
19176 fail:
19177 {
19178 if (temp2)
19179 delete arg2;
19180 }
19181 return NULL;
19182 }
19183
19184
19185 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19186 PyObject *resultobj = 0;
19187 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19188 wxString result;
19189 void *argp1 = 0 ;
19190 int res1 = 0 ;
19191 PyObject *swig_obj[1] ;
19192
19193 if (!args) SWIG_fail;
19194 swig_obj[0] = args;
19195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19196 if (!SWIG_IsOK(res1)) {
19197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19198 }
19199 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19200 {
19201 PyThreadState* __tstate = wxPyBeginAllowThreads();
19202 result = ((wxCommandEvent const *)arg1)->GetString();
19203 wxPyEndAllowThreads(__tstate);
19204 if (PyErr_Occurred()) SWIG_fail;
19205 }
19206 {
19207 #if wxUSE_UNICODE
19208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19209 #else
19210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19211 #endif
19212 }
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19220 PyObject *resultobj = 0;
19221 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19222 bool result;
19223 void *argp1 = 0 ;
19224 int res1 = 0 ;
19225 PyObject *swig_obj[1] ;
19226
19227 if (!args) SWIG_fail;
19228 swig_obj[0] = args;
19229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19230 if (!SWIG_IsOK(res1)) {
19231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19232 }
19233 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19234 {
19235 PyThreadState* __tstate = wxPyBeginAllowThreads();
19236 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19250 PyObject *resultobj = 0;
19251 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19252 bool result;
19253 void *argp1 = 0 ;
19254 int res1 = 0 ;
19255 PyObject *swig_obj[1] ;
19256
19257 if (!args) SWIG_fail;
19258 swig_obj[0] = args;
19259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19260 if (!SWIG_IsOK(res1)) {
19261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19262 }
19263 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 {
19271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19272 }
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19280 PyObject *resultobj = 0;
19281 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19282 long arg2 ;
19283 void *argp1 = 0 ;
19284 int res1 = 0 ;
19285 long val2 ;
19286 int ecode2 = 0 ;
19287 PyObject * obj0 = 0 ;
19288 PyObject * obj1 = 0 ;
19289 char * kwnames[] = {
19290 (char *) "self",(char *) "extraLong", NULL
19291 };
19292
19293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19295 if (!SWIG_IsOK(res1)) {
19296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19297 }
19298 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19299 ecode2 = SWIG_AsVal_long(obj1, &val2);
19300 if (!SWIG_IsOK(ecode2)) {
19301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19302 }
19303 arg2 = static_cast< long >(val2);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 (arg1)->SetExtraLong(arg2);
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_Py_Void();
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19318 PyObject *resultobj = 0;
19319 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19320 long result;
19321 void *argp1 = 0 ;
19322 int res1 = 0 ;
19323 PyObject *swig_obj[1] ;
19324
19325 if (!args) SWIG_fail;
19326 swig_obj[0] = args;
19327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19328 if (!SWIG_IsOK(res1)) {
19329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19330 }
19331 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 resultobj = SWIG_From_long(static_cast< long >(result));
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj = 0;
19347 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19348 int arg2 ;
19349 void *argp1 = 0 ;
19350 int res1 = 0 ;
19351 int val2 ;
19352 int ecode2 = 0 ;
19353 PyObject * obj0 = 0 ;
19354 PyObject * obj1 = 0 ;
19355 char * kwnames[] = {
19356 (char *) "self",(char *) "i", NULL
19357 };
19358
19359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19363 }
19364 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19365 ecode2 = SWIG_AsVal_int(obj1, &val2);
19366 if (!SWIG_IsOK(ecode2)) {
19367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19368 }
19369 arg2 = static_cast< int >(val2);
19370 {
19371 PyThreadState* __tstate = wxPyBeginAllowThreads();
19372 (arg1)->SetInt(arg2);
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_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19384 PyObject *resultobj = 0;
19385 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19386 int result;
19387 void *argp1 = 0 ;
19388 int res1 = 0 ;
19389 PyObject *swig_obj[1] ;
19390
19391 if (!args) SWIG_fail;
19392 swig_obj[0] = args;
19393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19394 if (!SWIG_IsOK(res1)) {
19395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19396 }
19397 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19398 {
19399 PyThreadState* __tstate = wxPyBeginAllowThreads();
19400 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19401 wxPyEndAllowThreads(__tstate);
19402 if (PyErr_Occurred()) SWIG_fail;
19403 }
19404 resultobj = SWIG_From_int(static_cast< int >(result));
19405 return resultobj;
19406 fail:
19407 return NULL;
19408 }
19409
19410
19411 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19412 PyObject *resultobj = 0;
19413 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19414 PyObject *result = 0 ;
19415 void *argp1 = 0 ;
19416 int res1 = 0 ;
19417 PyObject *swig_obj[1] ;
19418
19419 if (!args) SWIG_fail;
19420 swig_obj[0] = args;
19421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19422 if (!SWIG_IsOK(res1)) {
19423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19424 }
19425 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19426 {
19427 PyThreadState* __tstate = wxPyBeginAllowThreads();
19428 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19429 wxPyEndAllowThreads(__tstate);
19430 if (PyErr_Occurred()) SWIG_fail;
19431 }
19432 resultobj = result;
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19440 PyObject *resultobj = 0;
19441 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19442 PyObject *arg2 = (PyObject *) 0 ;
19443 void *argp1 = 0 ;
19444 int res1 = 0 ;
19445 PyObject * obj0 = 0 ;
19446 PyObject * obj1 = 0 ;
19447 char * kwnames[] = {
19448 (char *) "self",(char *) "clientData", NULL
19449 };
19450
19451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19453 if (!SWIG_IsOK(res1)) {
19454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19455 }
19456 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19457 arg2 = obj1;
19458 {
19459 PyThreadState* __tstate = wxPyBeginAllowThreads();
19460 wxCommandEvent_SetClientData(arg1,arg2);
19461 wxPyEndAllowThreads(__tstate);
19462 if (PyErr_Occurred()) SWIG_fail;
19463 }
19464 resultobj = SWIG_Py_Void();
19465 return resultobj;
19466 fail:
19467 return NULL;
19468 }
19469
19470
19471 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19472 PyObject *resultobj = 0;
19473 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19474 wxEvent *result = 0 ;
19475 void *argp1 = 0 ;
19476 int res1 = 0 ;
19477 PyObject *swig_obj[1] ;
19478
19479 if (!args) SWIG_fail;
19480 swig_obj[0] = args;
19481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19482 if (!SWIG_IsOK(res1)) {
19483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19484 }
19485 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19486 {
19487 PyThreadState* __tstate = wxPyBeginAllowThreads();
19488 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19489 wxPyEndAllowThreads(__tstate);
19490 if (PyErr_Occurred()) SWIG_fail;
19491 }
19492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19493 return resultobj;
19494 fail:
19495 return NULL;
19496 }
19497
19498
19499 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19500 PyObject *obj;
19501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19502 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19503 return SWIG_Py_Void();
19504 }
19505
19506 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19507 return SWIG_Python_InitShadowInstance(args);
19508 }
19509
19510 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj = 0;
19512 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19513 int arg2 = (int) 0 ;
19514 wxNotifyEvent *result = 0 ;
19515 int val1 ;
19516 int ecode1 = 0 ;
19517 int val2 ;
19518 int ecode2 = 0 ;
19519 PyObject * obj0 = 0 ;
19520 PyObject * obj1 = 0 ;
19521 char * kwnames[] = {
19522 (char *) "commandType",(char *) "winid", NULL
19523 };
19524
19525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19526 if (obj0) {
19527 ecode1 = SWIG_AsVal_int(obj0, &val1);
19528 if (!SWIG_IsOK(ecode1)) {
19529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19530 }
19531 arg1 = static_cast< wxEventType >(val1);
19532 }
19533 if (obj1) {
19534 ecode2 = SWIG_AsVal_int(obj1, &val2);
19535 if (!SWIG_IsOK(ecode2)) {
19536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19537 }
19538 arg2 = static_cast< int >(val2);
19539 }
19540 {
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19543 wxPyEndAllowThreads(__tstate);
19544 if (PyErr_Occurred()) SWIG_fail;
19545 }
19546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19554 PyObject *resultobj = 0;
19555 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19556 void *argp1 = 0 ;
19557 int res1 = 0 ;
19558 PyObject *swig_obj[1] ;
19559
19560 if (!args) SWIG_fail;
19561 swig_obj[0] = args;
19562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19563 if (!SWIG_IsOK(res1)) {
19564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19565 }
19566 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 (arg1)->Veto();
19570 wxPyEndAllowThreads(__tstate);
19571 if (PyErr_Occurred()) SWIG_fail;
19572 }
19573 resultobj = SWIG_Py_Void();
19574 return resultobj;
19575 fail:
19576 return NULL;
19577 }
19578
19579
19580 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19581 PyObject *resultobj = 0;
19582 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19583 void *argp1 = 0 ;
19584 int res1 = 0 ;
19585 PyObject *swig_obj[1] ;
19586
19587 if (!args) SWIG_fail;
19588 swig_obj[0] = args;
19589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19590 if (!SWIG_IsOK(res1)) {
19591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19592 }
19593 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19594 {
19595 PyThreadState* __tstate = wxPyBeginAllowThreads();
19596 (arg1)->Allow();
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 resultobj = SWIG_Py_Void();
19601 return resultobj;
19602 fail:
19603 return NULL;
19604 }
19605
19606
19607 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19608 PyObject *resultobj = 0;
19609 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19610 bool result;
19611 void *argp1 = 0 ;
19612 int res1 = 0 ;
19613 PyObject *swig_obj[1] ;
19614
19615 if (!args) SWIG_fail;
19616 swig_obj[0] = args;
19617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19618 if (!SWIG_IsOK(res1)) {
19619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19620 }
19621 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 result = (bool)(arg1)->IsAllowed();
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 {
19629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19630 }
19631 return resultobj;
19632 fail:
19633 return NULL;
19634 }
19635
19636
19637 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19638 PyObject *obj;
19639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19640 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19641 return SWIG_Py_Void();
19642 }
19643
19644 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 return SWIG_Python_InitShadowInstance(args);
19646 }
19647
19648 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19649 PyObject *resultobj = 0;
19650 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19651 int arg2 = (int) 0 ;
19652 int arg3 = (int) 0 ;
19653 int arg4 = (int) 0 ;
19654 wxScrollEvent *result = 0 ;
19655 int val1 ;
19656 int ecode1 = 0 ;
19657 int val2 ;
19658 int ecode2 = 0 ;
19659 int val3 ;
19660 int ecode3 = 0 ;
19661 int val4 ;
19662 int ecode4 = 0 ;
19663 PyObject * obj0 = 0 ;
19664 PyObject * obj1 = 0 ;
19665 PyObject * obj2 = 0 ;
19666 PyObject * obj3 = 0 ;
19667 char * kwnames[] = {
19668 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19669 };
19670
19671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19672 if (obj0) {
19673 ecode1 = SWIG_AsVal_int(obj0, &val1);
19674 if (!SWIG_IsOK(ecode1)) {
19675 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19676 }
19677 arg1 = static_cast< wxEventType >(val1);
19678 }
19679 if (obj1) {
19680 ecode2 = SWIG_AsVal_int(obj1, &val2);
19681 if (!SWIG_IsOK(ecode2)) {
19682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19683 }
19684 arg2 = static_cast< int >(val2);
19685 }
19686 if (obj2) {
19687 ecode3 = SWIG_AsVal_int(obj2, &val3);
19688 if (!SWIG_IsOK(ecode3)) {
19689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19690 }
19691 arg3 = static_cast< int >(val3);
19692 }
19693 if (obj3) {
19694 ecode4 = SWIG_AsVal_int(obj3, &val4);
19695 if (!SWIG_IsOK(ecode4)) {
19696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19697 }
19698 arg4 = static_cast< int >(val4);
19699 }
19700 {
19701 PyThreadState* __tstate = wxPyBeginAllowThreads();
19702 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19703 wxPyEndAllowThreads(__tstate);
19704 if (PyErr_Occurred()) SWIG_fail;
19705 }
19706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19714 PyObject *resultobj = 0;
19715 wxScrollEvent *arg1 = (wxScrollEvent *) 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_wxScrollEvent, 0 | 0 );
19724 if (!SWIG_IsOK(res1)) {
19725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19726 }
19727 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19728 {
19729 PyThreadState* __tstate = wxPyBeginAllowThreads();
19730 result = (int)((wxScrollEvent 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_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19742 PyObject *resultobj = 0;
19743 wxScrollEvent *arg1 = (wxScrollEvent *) 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_wxScrollEvent, 0 | 0 );
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19754 }
19755 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19756 {
19757 PyThreadState* __tstate = wxPyBeginAllowThreads();
19758 result = (int)((wxScrollEvent 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_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj = 0;
19771 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19785 if (!SWIG_IsOK(res1)) {
19786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19787 }
19788 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19789 ecode2 = SWIG_AsVal_int(obj1, &val2);
19790 if (!SWIG_IsOK(ecode2)) {
19791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_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_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj = 0;
19809 wxScrollEvent *arg1 = (wxScrollEvent *) 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:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19825 }
19826 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19827 ecode2 = SWIG_AsVal_int(obj1, &val2);
19828 if (!SWIG_IsOK(ecode2)) {
19829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_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 *ScrollEvent_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_wxScrollEvent, SWIG_NewClientData(obj));
19849 return SWIG_Py_Void();
19850 }
19851
19852 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19853 return SWIG_Python_InitShadowInstance(args);
19854 }
19855
19856 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19857 PyObject *resultobj = 0;
19858 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19859 int arg2 = (int) 0 ;
19860 int arg3 = (int) 0 ;
19861 wxScrollWinEvent *result = 0 ;
19862 int val1 ;
19863 int ecode1 = 0 ;
19864 int val2 ;
19865 int ecode2 = 0 ;
19866 int val3 ;
19867 int ecode3 = 0 ;
19868 PyObject * obj0 = 0 ;
19869 PyObject * obj1 = 0 ;
19870 PyObject * obj2 = 0 ;
19871 char * kwnames[] = {
19872 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19873 };
19874
19875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19876 if (obj0) {
19877 ecode1 = SWIG_AsVal_int(obj0, &val1);
19878 if (!SWIG_IsOK(ecode1)) {
19879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19880 }
19881 arg1 = static_cast< wxEventType >(val1);
19882 }
19883 if (obj1) {
19884 ecode2 = SWIG_AsVal_int(obj1, &val2);
19885 if (!SWIG_IsOK(ecode2)) {
19886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19887 }
19888 arg2 = static_cast< int >(val2);
19889 }
19890 if (obj2) {
19891 ecode3 = SWIG_AsVal_int(obj2, &val3);
19892 if (!SWIG_IsOK(ecode3)) {
19893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19894 }
19895 arg3 = static_cast< int >(val3);
19896 }
19897 {
19898 PyThreadState* __tstate = wxPyBeginAllowThreads();
19899 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19911 PyObject *resultobj = 0;
19912 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19913 int result;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 PyObject *swig_obj[1] ;
19917
19918 if (!args) SWIG_fail;
19919 swig_obj[0] = args;
19920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19921 if (!SWIG_IsOK(res1)) {
19922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19923 }
19924 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19925 {
19926 PyThreadState* __tstate = wxPyBeginAllowThreads();
19927 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19928 wxPyEndAllowThreads(__tstate);
19929 if (PyErr_Occurred()) SWIG_fail;
19930 }
19931 resultobj = SWIG_From_int(static_cast< int >(result));
19932 return resultobj;
19933 fail:
19934 return NULL;
19935 }
19936
19937
19938 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19939 PyObject *resultobj = 0;
19940 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19941 int result;
19942 void *argp1 = 0 ;
19943 int res1 = 0 ;
19944 PyObject *swig_obj[1] ;
19945
19946 if (!args) SWIG_fail;
19947 swig_obj[0] = args;
19948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19949 if (!SWIG_IsOK(res1)) {
19950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19951 }
19952 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19953 {
19954 PyThreadState* __tstate = wxPyBeginAllowThreads();
19955 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19956 wxPyEndAllowThreads(__tstate);
19957 if (PyErr_Occurred()) SWIG_fail;
19958 }
19959 resultobj = SWIG_From_int(static_cast< int >(result));
19960 return resultobj;
19961 fail:
19962 return NULL;
19963 }
19964
19965
19966 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19967 PyObject *resultobj = 0;
19968 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19969 int arg2 ;
19970 void *argp1 = 0 ;
19971 int res1 = 0 ;
19972 int val2 ;
19973 int ecode2 = 0 ;
19974 PyObject * obj0 = 0 ;
19975 PyObject * obj1 = 0 ;
19976 char * kwnames[] = {
19977 (char *) "self",(char *) "orient", NULL
19978 };
19979
19980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19982 if (!SWIG_IsOK(res1)) {
19983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19984 }
19985 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19986 ecode2 = SWIG_AsVal_int(obj1, &val2);
19987 if (!SWIG_IsOK(ecode2)) {
19988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19989 }
19990 arg2 = static_cast< int >(val2);
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 (arg1)->SetOrientation(arg2);
19994 wxPyEndAllowThreads(__tstate);
19995 if (PyErr_Occurred()) SWIG_fail;
19996 }
19997 resultobj = SWIG_Py_Void();
19998 return resultobj;
19999 fail:
20000 return NULL;
20001 }
20002
20003
20004 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20005 PyObject *resultobj = 0;
20006 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20007 int arg2 ;
20008 void *argp1 = 0 ;
20009 int res1 = 0 ;
20010 int val2 ;
20011 int ecode2 = 0 ;
20012 PyObject * obj0 = 0 ;
20013 PyObject * obj1 = 0 ;
20014 char * kwnames[] = {
20015 (char *) "self",(char *) "pos", NULL
20016 };
20017
20018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20020 if (!SWIG_IsOK(res1)) {
20021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20022 }
20023 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20024 ecode2 = SWIG_AsVal_int(obj1, &val2);
20025 if (!SWIG_IsOK(ecode2)) {
20026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20027 }
20028 arg2 = static_cast< int >(val2);
20029 {
20030 PyThreadState* __tstate = wxPyBeginAllowThreads();
20031 (arg1)->SetPosition(arg2);
20032 wxPyEndAllowThreads(__tstate);
20033 if (PyErr_Occurred()) SWIG_fail;
20034 }
20035 resultobj = SWIG_Py_Void();
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20043 PyObject *obj;
20044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20045 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20046 return SWIG_Py_Void();
20047 }
20048
20049 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20050 return SWIG_Python_InitShadowInstance(args);
20051 }
20052
20053 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20054 PyObject *resultobj = 0;
20055 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20056 wxMouseEvent *result = 0 ;
20057 int val1 ;
20058 int ecode1 = 0 ;
20059 PyObject * obj0 = 0 ;
20060 char * kwnames[] = {
20061 (char *) "mouseType", NULL
20062 };
20063
20064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20065 if (obj0) {
20066 ecode1 = SWIG_AsVal_int(obj0, &val1);
20067 if (!SWIG_IsOK(ecode1)) {
20068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20069 }
20070 arg1 = static_cast< wxEventType >(val1);
20071 }
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 {
20079 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20080 }
20081 return resultobj;
20082 fail:
20083 return NULL;
20084 }
20085
20086
20087 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20088 PyObject *resultobj = 0;
20089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20090 bool result;
20091 void *argp1 = 0 ;
20092 int res1 = 0 ;
20093 PyObject *swig_obj[1] ;
20094
20095 if (!args) SWIG_fail;
20096 swig_obj[0] = args;
20097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20098 if (!SWIG_IsOK(res1)) {
20099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20100 }
20101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20110 }
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20118 PyObject *resultobj = 0;
20119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20120 int arg2 = (int) wxMOUSE_BTN_ANY ;
20121 bool result;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 int val2 ;
20125 int ecode2 = 0 ;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 char * kwnames[] = {
20129 (char *) "self",(char *) "but", NULL
20130 };
20131
20132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20136 }
20137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20138 if (obj1) {
20139 ecode2 = SWIG_AsVal_int(obj1, &val2);
20140 if (!SWIG_IsOK(ecode2)) {
20141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20142 }
20143 arg2 = static_cast< int >(val2);
20144 }
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20153 }
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20161 PyObject *resultobj = 0;
20162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20163 int arg2 = (int) wxMOUSE_BTN_ANY ;
20164 bool result;
20165 void *argp1 = 0 ;
20166 int res1 = 0 ;
20167 int val2 ;
20168 int ecode2 = 0 ;
20169 PyObject * obj0 = 0 ;
20170 PyObject * obj1 = 0 ;
20171 char * kwnames[] = {
20172 (char *) "self",(char *) "but", NULL
20173 };
20174
20175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20177 if (!SWIG_IsOK(res1)) {
20178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20179 }
20180 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20181 if (obj1) {
20182 ecode2 = SWIG_AsVal_int(obj1, &val2);
20183 if (!SWIG_IsOK(ecode2)) {
20184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20185 }
20186 arg2 = static_cast< int >(val2);
20187 }
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20196 }
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj = 0;
20205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20206 int arg2 = (int) wxMOUSE_BTN_ANY ;
20207 bool result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 int val2 ;
20211 int ecode2 = 0 ;
20212 PyObject * obj0 = 0 ;
20213 PyObject * obj1 = 0 ;
20214 char * kwnames[] = {
20215 (char *) "self",(char *) "but", NULL
20216 };
20217
20218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20222 }
20223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20224 if (obj1) {
20225 ecode2 = SWIG_AsVal_int(obj1, &val2);
20226 if (!SWIG_IsOK(ecode2)) {
20227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20228 }
20229 arg2 = static_cast< int >(val2);
20230 }
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 {
20238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20239 }
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20247 PyObject *resultobj = 0;
20248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20249 int arg2 ;
20250 bool result;
20251 void *argp1 = 0 ;
20252 int res1 = 0 ;
20253 int val2 ;
20254 int ecode2 = 0 ;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 char * kwnames[] = {
20258 (char *) "self",(char *) "button", NULL
20259 };
20260
20261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20263 if (!SWIG_IsOK(res1)) {
20264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20265 }
20266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20267 ecode2 = SWIG_AsVal_int(obj1, &val2);
20268 if (!SWIG_IsOK(ecode2)) {
20269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20270 }
20271 arg2 = static_cast< int >(val2);
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20275 wxPyEndAllowThreads(__tstate);
20276 if (PyErr_Occurred()) SWIG_fail;
20277 }
20278 {
20279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20280 }
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj = 0;
20289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20290 int arg2 ;
20291 bool result;
20292 void *argp1 = 0 ;
20293 int res1 = 0 ;
20294 int val2 ;
20295 int ecode2 = 0 ;
20296 PyObject * obj0 = 0 ;
20297 PyObject * obj1 = 0 ;
20298 char * kwnames[] = {
20299 (char *) "self",(char *) "but", NULL
20300 };
20301
20302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20304 if (!SWIG_IsOK(res1)) {
20305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20306 }
20307 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20308 ecode2 = SWIG_AsVal_int(obj1, &val2);
20309 if (!SWIG_IsOK(ecode2)) {
20310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20311 }
20312 arg2 = static_cast< int >(val2);
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20316 wxPyEndAllowThreads(__tstate);
20317 if (PyErr_Occurred()) SWIG_fail;
20318 }
20319 {
20320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20321 }
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20329 PyObject *resultobj = 0;
20330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20331 int result;
20332 void *argp1 = 0 ;
20333 int res1 = 0 ;
20334 PyObject *swig_obj[1] ;
20335
20336 if (!args) SWIG_fail;
20337 swig_obj[0] = args;
20338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20339 if (!SWIG_IsOK(res1)) {
20340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20341 }
20342 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20343 {
20344 PyThreadState* __tstate = wxPyBeginAllowThreads();
20345 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20346 wxPyEndAllowThreads(__tstate);
20347 if (PyErr_Occurred()) SWIG_fail;
20348 }
20349 resultobj = SWIG_From_int(static_cast< int >(result));
20350 return resultobj;
20351 fail:
20352 return NULL;
20353 }
20354
20355
20356 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20357 PyObject *resultobj = 0;
20358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20359 bool result;
20360 void *argp1 = 0 ;
20361 int res1 = 0 ;
20362 PyObject *swig_obj[1] ;
20363
20364 if (!args) SWIG_fail;
20365 swig_obj[0] = args;
20366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20367 if (!SWIG_IsOK(res1)) {
20368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20369 }
20370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 {
20378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20379 }
20380 return resultobj;
20381 fail:
20382 return NULL;
20383 }
20384
20385
20386 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387 PyObject *resultobj = 0;
20388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20389 bool result;
20390 void *argp1 = 0 ;
20391 int res1 = 0 ;
20392 PyObject *swig_obj[1] ;
20393
20394 if (!args) SWIG_fail;
20395 swig_obj[0] = args;
20396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20397 if (!SWIG_IsOK(res1)) {
20398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20399 }
20400 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 {
20408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20409 }
20410 return resultobj;
20411 fail:
20412 return NULL;
20413 }
20414
20415
20416 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20417 PyObject *resultobj = 0;
20418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20419 bool result;
20420 void *argp1 = 0 ;
20421 int res1 = 0 ;
20422 PyObject *swig_obj[1] ;
20423
20424 if (!args) SWIG_fail;
20425 swig_obj[0] = args;
20426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20427 if (!SWIG_IsOK(res1)) {
20428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20429 }
20430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20431 {
20432 PyThreadState* __tstate = wxPyBeginAllowThreads();
20433 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 {
20438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20439 }
20440 return resultobj;
20441 fail:
20442 return NULL;
20443 }
20444
20445
20446 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20447 PyObject *resultobj = 0;
20448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20449 bool result;
20450 void *argp1 = 0 ;
20451 int res1 = 0 ;
20452 PyObject *swig_obj[1] ;
20453
20454 if (!args) SWIG_fail;
20455 swig_obj[0] = args;
20456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20457 if (!SWIG_IsOK(res1)) {
20458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20459 }
20460 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20461 {
20462 PyThreadState* __tstate = wxPyBeginAllowThreads();
20463 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20464 wxPyEndAllowThreads(__tstate);
20465 if (PyErr_Occurred()) SWIG_fail;
20466 }
20467 {
20468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20469 }
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20477 PyObject *resultobj = 0;
20478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20479 bool result;
20480 void *argp1 = 0 ;
20481 int res1 = 0 ;
20482 PyObject *swig_obj[1] ;
20483
20484 if (!args) SWIG_fail;
20485 swig_obj[0] = args;
20486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20487 if (!SWIG_IsOK(res1)) {
20488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20489 }
20490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20491 {
20492 PyThreadState* __tstate = wxPyBeginAllowThreads();
20493 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20494 wxPyEndAllowThreads(__tstate);
20495 if (PyErr_Occurred()) SWIG_fail;
20496 }
20497 {
20498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20499 }
20500 return resultobj;
20501 fail:
20502 return NULL;
20503 }
20504
20505
20506 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20507 PyObject *resultobj = 0;
20508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20509 bool result;
20510 void *argp1 = 0 ;
20511 int res1 = 0 ;
20512 PyObject *swig_obj[1] ;
20513
20514 if (!args) SWIG_fail;
20515 swig_obj[0] = args;
20516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20517 if (!SWIG_IsOK(res1)) {
20518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20519 }
20520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20521 {
20522 PyThreadState* __tstate = wxPyBeginAllowThreads();
20523 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20524 wxPyEndAllowThreads(__tstate);
20525 if (PyErr_Occurred()) SWIG_fail;
20526 }
20527 {
20528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20529 }
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20537 PyObject *resultobj = 0;
20538 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20539 bool result;
20540 void *argp1 = 0 ;
20541 int res1 = 0 ;
20542 PyObject *swig_obj[1] ;
20543
20544 if (!args) SWIG_fail;
20545 swig_obj[0] = args;
20546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20547 if (!SWIG_IsOK(res1)) {
20548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20549 }
20550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20554 wxPyEndAllowThreads(__tstate);
20555 if (PyErr_Occurred()) SWIG_fail;
20556 }
20557 {
20558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20559 }
20560 return resultobj;
20561 fail:
20562 return NULL;
20563 }
20564
20565
20566 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20567 PyObject *resultobj = 0;
20568 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20569 bool result;
20570 void *argp1 = 0 ;
20571 int res1 = 0 ;
20572 PyObject *swig_obj[1] ;
20573
20574 if (!args) SWIG_fail;
20575 swig_obj[0] = args;
20576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20577 if (!SWIG_IsOK(res1)) {
20578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20579 }
20580 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20581 {
20582 PyThreadState* __tstate = wxPyBeginAllowThreads();
20583 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20584 wxPyEndAllowThreads(__tstate);
20585 if (PyErr_Occurred()) SWIG_fail;
20586 }
20587 {
20588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20589 }
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20597 PyObject *resultobj = 0;
20598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20599 bool result;
20600 void *argp1 = 0 ;
20601 int res1 = 0 ;
20602 PyObject *swig_obj[1] ;
20603
20604 if (!args) SWIG_fail;
20605 swig_obj[0] = args;
20606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20607 if (!SWIG_IsOK(res1)) {
20608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20609 }
20610 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 {
20618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20619 }
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20627 PyObject *resultobj = 0;
20628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20629 bool result;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 PyObject *swig_obj[1] ;
20633
20634 if (!args) SWIG_fail;
20635 swig_obj[0] = args;
20636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20637 if (!SWIG_IsOK(res1)) {
20638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20639 }
20640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20641 {
20642 PyThreadState* __tstate = wxPyBeginAllowThreads();
20643 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20644 wxPyEndAllowThreads(__tstate);
20645 if (PyErr_Occurred()) SWIG_fail;
20646 }
20647 {
20648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20657 PyObject *resultobj = 0;
20658 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20659 bool result;
20660 void *argp1 = 0 ;
20661 int res1 = 0 ;
20662 PyObject *swig_obj[1] ;
20663
20664 if (!args) SWIG_fail;
20665 swig_obj[0] = args;
20666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20667 if (!SWIG_IsOK(res1)) {
20668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20669 }
20670 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 {
20678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20679 }
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20687 PyObject *resultobj = 0;
20688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20689 bool result;
20690 void *argp1 = 0 ;
20691 int res1 = 0 ;
20692 PyObject *swig_obj[1] ;
20693
20694 if (!args) SWIG_fail;
20695 swig_obj[0] = args;
20696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20697 if (!SWIG_IsOK(res1)) {
20698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20699 }
20700 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20709 }
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20717 PyObject *resultobj = 0;
20718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20719 bool result;
20720 void *argp1 = 0 ;
20721 int res1 = 0 ;
20722 PyObject *swig_obj[1] ;
20723
20724 if (!args) SWIG_fail;
20725 swig_obj[0] = args;
20726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20727 if (!SWIG_IsOK(res1)) {
20728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20729 }
20730 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20747 PyObject *resultobj = 0;
20748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20749 bool result;
20750 void *argp1 = 0 ;
20751 int res1 = 0 ;
20752 PyObject *swig_obj[1] ;
20753
20754 if (!args) SWIG_fail;
20755 swig_obj[0] = args;
20756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20757 if (!SWIG_IsOK(res1)) {
20758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20759 }
20760 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20761 {
20762 PyThreadState* __tstate = wxPyBeginAllowThreads();
20763 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 {
20768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20769 }
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20777 PyObject *resultobj = 0;
20778 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20779 bool result;
20780 void *argp1 = 0 ;
20781 int res1 = 0 ;
20782 PyObject *swig_obj[1] ;
20783
20784 if (!args) SWIG_fail;
20785 swig_obj[0] = args;
20786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20787 if (!SWIG_IsOK(res1)) {
20788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20789 }
20790 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20791 {
20792 PyThreadState* __tstate = wxPyBeginAllowThreads();
20793 result = (bool)(arg1)->LeftIsDown();
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 {
20798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20799 }
20800 return resultobj;
20801 fail:
20802 return NULL;
20803 }
20804
20805
20806 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20807 PyObject *resultobj = 0;
20808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20809 bool result;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 PyObject *swig_obj[1] ;
20813
20814 if (!args) SWIG_fail;
20815 swig_obj[0] = args;
20816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20819 }
20820 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (bool)(arg1)->MiddleIsDown();
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20829 }
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20837 PyObject *resultobj = 0;
20838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20839 bool result;
20840 void *argp1 = 0 ;
20841 int res1 = 0 ;
20842 PyObject *swig_obj[1] ;
20843
20844 if (!args) SWIG_fail;
20845 swig_obj[0] = args;
20846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20847 if (!SWIG_IsOK(res1)) {
20848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20849 }
20850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = (bool)(arg1)->RightIsDown();
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20859 }
20860 return resultobj;
20861 fail:
20862 return NULL;
20863 }
20864
20865
20866 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20869 bool result;
20870 void *argp1 = 0 ;
20871 int res1 = 0 ;
20872 PyObject *swig_obj[1] ;
20873
20874 if (!args) SWIG_fail;
20875 swig_obj[0] = args;
20876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20877 if (!SWIG_IsOK(res1)) {
20878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20879 }
20880 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20884 wxPyEndAllowThreads(__tstate);
20885 if (PyErr_Occurred()) SWIG_fail;
20886 }
20887 {
20888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20889 }
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20897 PyObject *resultobj = 0;
20898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20899 bool result;
20900 void *argp1 = 0 ;
20901 int res1 = 0 ;
20902 PyObject *swig_obj[1] ;
20903
20904 if (!args) SWIG_fail;
20905 swig_obj[0] = args;
20906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20907 if (!SWIG_IsOK(res1)) {
20908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20909 }
20910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20914 wxPyEndAllowThreads(__tstate);
20915 if (PyErr_Occurred()) SWIG_fail;
20916 }
20917 {
20918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20919 }
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20927 PyObject *resultobj = 0;
20928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20929 bool result;
20930 void *argp1 = 0 ;
20931 int res1 = 0 ;
20932 PyObject *swig_obj[1] ;
20933
20934 if (!args) SWIG_fail;
20935 swig_obj[0] = args;
20936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20937 if (!SWIG_IsOK(res1)) {
20938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20939 }
20940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 {
20948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20949 }
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20957 PyObject *resultobj = 0;
20958 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20959 bool result;
20960 void *argp1 = 0 ;
20961 int res1 = 0 ;
20962 PyObject *swig_obj[1] ;
20963
20964 if (!args) SWIG_fail;
20965 swig_obj[0] = args;
20966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20967 if (!SWIG_IsOK(res1)) {
20968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20969 }
20970 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20987 PyObject *resultobj = 0;
20988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20989 wxPoint result;
20990 void *argp1 = 0 ;
20991 int res1 = 0 ;
20992 PyObject *swig_obj[1] ;
20993
20994 if (!args) SWIG_fail;
20995 swig_obj[0] = args;
20996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20997 if (!SWIG_IsOK(res1)) {
20998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20999 }
21000 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 result = (arg1)->GetPosition();
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21017 long *arg2 = (long *) 0 ;
21018 long *arg3 = (long *) 0 ;
21019 void *argp1 = 0 ;
21020 int res1 = 0 ;
21021 long temp2 ;
21022 int res2 = SWIG_TMPOBJ ;
21023 long temp3 ;
21024 int res3 = SWIG_TMPOBJ ;
21025 PyObject *swig_obj[1] ;
21026
21027 arg2 = &temp2;
21028 arg3 = &temp3;
21029 if (!args) SWIG_fail;
21030 swig_obj[0] = args;
21031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21032 if (!SWIG_IsOK(res1)) {
21033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21034 }
21035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 (arg1)->GetPosition(arg2,arg3);
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 resultobj = SWIG_Py_Void();
21043 if (SWIG_IsTmpObj(res2)) {
21044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21045 } else {
21046 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21048 }
21049 if (SWIG_IsTmpObj(res3)) {
21050 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21051 } else {
21052 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21054 }
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 wxDC *arg2 = 0 ;
21065 wxPoint result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 void *argp2 = 0 ;
21069 int res2 = 0 ;
21070 PyObject * obj0 = 0 ;
21071 PyObject * obj1 = 0 ;
21072 char * kwnames[] = {
21073 (char *) "self",(char *) "dc", NULL
21074 };
21075
21076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21078 if (!SWIG_IsOK(res1)) {
21079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21080 }
21081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21082 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21083 if (!SWIG_IsOK(res2)) {
21084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21085 }
21086 if (!argp2) {
21087 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21088 }
21089 arg2 = reinterpret_cast< wxDC * >(argp2);
21090 {
21091 PyThreadState* __tstate = wxPyBeginAllowThreads();
21092 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21093 wxPyEndAllowThreads(__tstate);
21094 if (PyErr_Occurred()) SWIG_fail;
21095 }
21096 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21097 return resultobj;
21098 fail:
21099 return NULL;
21100 }
21101
21102
21103 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21104 PyObject *resultobj = 0;
21105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21106 int result;
21107 void *argp1 = 0 ;
21108 int res1 = 0 ;
21109 PyObject *swig_obj[1] ;
21110
21111 if (!args) SWIG_fail;
21112 swig_obj[0] = args;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21116 }
21117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = (int)((wxMouseEvent const *)arg1)->GetX();
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 resultobj = SWIG_From_int(static_cast< int >(result));
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132 PyObject *resultobj = 0;
21133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21134 int result;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 PyObject *swig_obj[1] ;
21138
21139 if (!args) SWIG_fail;
21140 swig_obj[0] = args;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21144 }
21145 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (int)((wxMouseEvent const *)arg1)->GetY();
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 resultobj = SWIG_From_int(static_cast< int >(result));
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(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_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21172 }
21173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 resultobj = SWIG_From_int(static_cast< int >(result));
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21188 PyObject *resultobj = 0;
21189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21190 int result;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 PyObject *swig_obj[1] ;
21194
21195 if (!args) SWIG_fail;
21196 swig_obj[0] = args;
21197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21200 }
21201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 resultobj = SWIG_From_int(static_cast< int >(result));
21209 return resultobj;
21210 fail:
21211 return NULL;
21212 }
21213
21214
21215 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21216 PyObject *resultobj = 0;
21217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21218 int result;
21219 void *argp1 = 0 ;
21220 int res1 = 0 ;
21221 PyObject *swig_obj[1] ;
21222
21223 if (!args) SWIG_fail;
21224 swig_obj[0] = args;
21225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21226 if (!SWIG_IsOK(res1)) {
21227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21228 }
21229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21230 {
21231 PyThreadState* __tstate = wxPyBeginAllowThreads();
21232 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21233 wxPyEndAllowThreads(__tstate);
21234 if (PyErr_Occurred()) SWIG_fail;
21235 }
21236 resultobj = SWIG_From_int(static_cast< int >(result));
21237 return resultobj;
21238 fail:
21239 return NULL;
21240 }
21241
21242
21243 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21244 PyObject *resultobj = 0;
21245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21246 bool result;
21247 void *argp1 = 0 ;
21248 int res1 = 0 ;
21249 PyObject *swig_obj[1] ;
21250
21251 if (!args) SWIG_fail;
21252 swig_obj[0] = args;
21253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21256 }
21257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21258 {
21259 PyThreadState* __tstate = wxPyBeginAllowThreads();
21260 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21261 wxPyEndAllowThreads(__tstate);
21262 if (PyErr_Occurred()) SWIG_fail;
21263 }
21264 {
21265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21266 }
21267 return resultobj;
21268 fail:
21269 return NULL;
21270 }
21271
21272
21273 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21274 PyObject *resultobj = 0;
21275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21276 int arg2 ;
21277 void *argp1 = 0 ;
21278 int res1 = 0 ;
21279 int val2 ;
21280 int ecode2 = 0 ;
21281 PyObject *swig_obj[2] ;
21282
21283 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21285 if (!SWIG_IsOK(res1)) {
21286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21287 }
21288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21289 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21290 if (!SWIG_IsOK(ecode2)) {
21291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21292 }
21293 arg2 = static_cast< int >(val2);
21294 if (arg1) (arg1)->m_x = arg2;
21295
21296 resultobj = SWIG_Py_Void();
21297 return resultobj;
21298 fail:
21299 return NULL;
21300 }
21301
21302
21303 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21304 PyObject *resultobj = 0;
21305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21306 int result;
21307 void *argp1 = 0 ;
21308 int res1 = 0 ;
21309 PyObject *swig_obj[1] ;
21310
21311 if (!args) SWIG_fail;
21312 swig_obj[0] = args;
21313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21314 if (!SWIG_IsOK(res1)) {
21315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21316 }
21317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21318 result = (int) ((arg1)->m_x);
21319 resultobj = SWIG_From_int(static_cast< int >(result));
21320 return resultobj;
21321 fail:
21322 return NULL;
21323 }
21324
21325
21326 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21327 PyObject *resultobj = 0;
21328 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21329 int arg2 ;
21330 void *argp1 = 0 ;
21331 int res1 = 0 ;
21332 int val2 ;
21333 int ecode2 = 0 ;
21334 PyObject *swig_obj[2] ;
21335
21336 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21338 if (!SWIG_IsOK(res1)) {
21339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21340 }
21341 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21342 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21343 if (!SWIG_IsOK(ecode2)) {
21344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21345 }
21346 arg2 = static_cast< int >(val2);
21347 if (arg1) (arg1)->m_y = arg2;
21348
21349 resultobj = SWIG_Py_Void();
21350 return resultobj;
21351 fail:
21352 return NULL;
21353 }
21354
21355
21356 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21357 PyObject *resultobj = 0;
21358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21359 int result;
21360 void *argp1 = 0 ;
21361 int res1 = 0 ;
21362 PyObject *swig_obj[1] ;
21363
21364 if (!args) SWIG_fail;
21365 swig_obj[0] = args;
21366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21367 if (!SWIG_IsOK(res1)) {
21368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21369 }
21370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21371 result = (int) ((arg1)->m_y);
21372 resultobj = SWIG_From_int(static_cast< int >(result));
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21380 PyObject *resultobj = 0;
21381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21382 bool arg2 ;
21383 void *argp1 = 0 ;
21384 int res1 = 0 ;
21385 bool val2 ;
21386 int ecode2 = 0 ;
21387 PyObject *swig_obj[2] ;
21388
21389 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21391 if (!SWIG_IsOK(res1)) {
21392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21393 }
21394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21395 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21396 if (!SWIG_IsOK(ecode2)) {
21397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21398 }
21399 arg2 = static_cast< bool >(val2);
21400 if (arg1) (arg1)->m_leftDown = arg2;
21401
21402 resultobj = SWIG_Py_Void();
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21410 PyObject *resultobj = 0;
21411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21412 bool result;
21413 void *argp1 = 0 ;
21414 int res1 = 0 ;
21415 PyObject *swig_obj[1] ;
21416
21417 if (!args) SWIG_fail;
21418 swig_obj[0] = args;
21419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21420 if (!SWIG_IsOK(res1)) {
21421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21422 }
21423 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21424 result = (bool) ((arg1)->m_leftDown);
21425 {
21426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21427 }
21428 return resultobj;
21429 fail:
21430 return NULL;
21431 }
21432
21433
21434 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21435 PyObject *resultobj = 0;
21436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21437 bool arg2 ;
21438 void *argp1 = 0 ;
21439 int res1 = 0 ;
21440 bool val2 ;
21441 int ecode2 = 0 ;
21442 PyObject *swig_obj[2] ;
21443
21444 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21446 if (!SWIG_IsOK(res1)) {
21447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21448 }
21449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21450 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21451 if (!SWIG_IsOK(ecode2)) {
21452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21453 }
21454 arg2 = static_cast< bool >(val2);
21455 if (arg1) (arg1)->m_middleDown = arg2;
21456
21457 resultobj = SWIG_Py_Void();
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21465 PyObject *resultobj = 0;
21466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21467 bool result;
21468 void *argp1 = 0 ;
21469 int res1 = 0 ;
21470 PyObject *swig_obj[1] ;
21471
21472 if (!args) SWIG_fail;
21473 swig_obj[0] = args;
21474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21475 if (!SWIG_IsOK(res1)) {
21476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21477 }
21478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21479 result = (bool) ((arg1)->m_middleDown);
21480 {
21481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21482 }
21483 return resultobj;
21484 fail:
21485 return NULL;
21486 }
21487
21488
21489 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21490 PyObject *resultobj = 0;
21491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21492 bool arg2 ;
21493 void *argp1 = 0 ;
21494 int res1 = 0 ;
21495 bool val2 ;
21496 int ecode2 = 0 ;
21497 PyObject *swig_obj[2] ;
21498
21499 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21501 if (!SWIG_IsOK(res1)) {
21502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21503 }
21504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21505 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21506 if (!SWIG_IsOK(ecode2)) {
21507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21508 }
21509 arg2 = static_cast< bool >(val2);
21510 if (arg1) (arg1)->m_rightDown = arg2;
21511
21512 resultobj = SWIG_Py_Void();
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520 PyObject *resultobj = 0;
21521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21522 bool result;
21523 void *argp1 = 0 ;
21524 int res1 = 0 ;
21525 PyObject *swig_obj[1] ;
21526
21527 if (!args) SWIG_fail;
21528 swig_obj[0] = args;
21529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21530 if (!SWIG_IsOK(res1)) {
21531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21532 }
21533 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21534 result = (bool) ((arg1)->m_rightDown);
21535 {
21536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21537 }
21538 return resultobj;
21539 fail:
21540 return NULL;
21541 }
21542
21543
21544 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21545 PyObject *resultobj = 0;
21546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21547 bool arg2 ;
21548 void *argp1 = 0 ;
21549 int res1 = 0 ;
21550 bool val2 ;
21551 int ecode2 = 0 ;
21552 PyObject *swig_obj[2] ;
21553
21554 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21556 if (!SWIG_IsOK(res1)) {
21557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21558 }
21559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21560 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21561 if (!SWIG_IsOK(ecode2)) {
21562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21563 }
21564 arg2 = static_cast< bool >(val2);
21565 if (arg1) (arg1)->m_controlDown = arg2;
21566
21567 resultobj = SWIG_Py_Void();
21568 return resultobj;
21569 fail:
21570 return NULL;
21571 }
21572
21573
21574 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21575 PyObject *resultobj = 0;
21576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21577 bool result;
21578 void *argp1 = 0 ;
21579 int res1 = 0 ;
21580 PyObject *swig_obj[1] ;
21581
21582 if (!args) SWIG_fail;
21583 swig_obj[0] = args;
21584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21587 }
21588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21589 result = (bool) ((arg1)->m_controlDown);
21590 {
21591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21592 }
21593 return resultobj;
21594 fail:
21595 return NULL;
21596 }
21597
21598
21599 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21600 PyObject *resultobj = 0;
21601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21602 bool arg2 ;
21603 void *argp1 = 0 ;
21604 int res1 = 0 ;
21605 bool val2 ;
21606 int ecode2 = 0 ;
21607 PyObject *swig_obj[2] ;
21608
21609 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21611 if (!SWIG_IsOK(res1)) {
21612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21613 }
21614 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21615 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21616 if (!SWIG_IsOK(ecode2)) {
21617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21618 }
21619 arg2 = static_cast< bool >(val2);
21620 if (arg1) (arg1)->m_shiftDown = arg2;
21621
21622 resultobj = SWIG_Py_Void();
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21630 PyObject *resultobj = 0;
21631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21632 bool result;
21633 void *argp1 = 0 ;
21634 int res1 = 0 ;
21635 PyObject *swig_obj[1] ;
21636
21637 if (!args) SWIG_fail;
21638 swig_obj[0] = args;
21639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21640 if (!SWIG_IsOK(res1)) {
21641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21642 }
21643 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21644 result = (bool) ((arg1)->m_shiftDown);
21645 {
21646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21647 }
21648 return resultobj;
21649 fail:
21650 return NULL;
21651 }
21652
21653
21654 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21655 PyObject *resultobj = 0;
21656 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21657 bool arg2 ;
21658 void *argp1 = 0 ;
21659 int res1 = 0 ;
21660 bool val2 ;
21661 int ecode2 = 0 ;
21662 PyObject *swig_obj[2] ;
21663
21664 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21666 if (!SWIG_IsOK(res1)) {
21667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21668 }
21669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21670 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21671 if (!SWIG_IsOK(ecode2)) {
21672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21673 }
21674 arg2 = static_cast< bool >(val2);
21675 if (arg1) (arg1)->m_altDown = arg2;
21676
21677 resultobj = SWIG_Py_Void();
21678 return resultobj;
21679 fail:
21680 return NULL;
21681 }
21682
21683
21684 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21685 PyObject *resultobj = 0;
21686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21687 bool result;
21688 void *argp1 = 0 ;
21689 int res1 = 0 ;
21690 PyObject *swig_obj[1] ;
21691
21692 if (!args) SWIG_fail;
21693 swig_obj[0] = args;
21694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21695 if (!SWIG_IsOK(res1)) {
21696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21697 }
21698 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21699 result = (bool) ((arg1)->m_altDown);
21700 {
21701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21702 }
21703 return resultobj;
21704 fail:
21705 return NULL;
21706 }
21707
21708
21709 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21710 PyObject *resultobj = 0;
21711 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21712 bool arg2 ;
21713 void *argp1 = 0 ;
21714 int res1 = 0 ;
21715 bool val2 ;
21716 int ecode2 = 0 ;
21717 PyObject *swig_obj[2] ;
21718
21719 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21723 }
21724 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21725 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21726 if (!SWIG_IsOK(ecode2)) {
21727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21728 }
21729 arg2 = static_cast< bool >(val2);
21730 if (arg1) (arg1)->m_metaDown = arg2;
21731
21732 resultobj = SWIG_Py_Void();
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *resultobj = 0;
21741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21742 bool result;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 PyObject *swig_obj[1] ;
21746
21747 if (!args) SWIG_fail;
21748 swig_obj[0] = args;
21749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21750 if (!SWIG_IsOK(res1)) {
21751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21752 }
21753 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21754 result = (bool) ((arg1)->m_metaDown);
21755 {
21756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21757 }
21758 return resultobj;
21759 fail:
21760 return NULL;
21761 }
21762
21763
21764 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21765 PyObject *resultobj = 0;
21766 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21767 int arg2 ;
21768 void *argp1 = 0 ;
21769 int res1 = 0 ;
21770 int val2 ;
21771 int ecode2 = 0 ;
21772 PyObject *swig_obj[2] ;
21773
21774 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21776 if (!SWIG_IsOK(res1)) {
21777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21778 }
21779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21780 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21781 if (!SWIG_IsOK(ecode2)) {
21782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21783 }
21784 arg2 = static_cast< int >(val2);
21785 if (arg1) (arg1)->m_wheelRotation = arg2;
21786
21787 resultobj = SWIG_Py_Void();
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21797 int result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 PyObject *swig_obj[1] ;
21801
21802 if (!args) SWIG_fail;
21803 swig_obj[0] = args;
21804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21805 if (!SWIG_IsOK(res1)) {
21806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21807 }
21808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21809 result = (int) ((arg1)->m_wheelRotation);
21810 resultobj = SWIG_From_int(static_cast< int >(result));
21811 return resultobj;
21812 fail:
21813 return NULL;
21814 }
21815
21816
21817 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21818 PyObject *resultobj = 0;
21819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21820 int arg2 ;
21821 void *argp1 = 0 ;
21822 int res1 = 0 ;
21823 int val2 ;
21824 int ecode2 = 0 ;
21825 PyObject *swig_obj[2] ;
21826
21827 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21829 if (!SWIG_IsOK(res1)) {
21830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21831 }
21832 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21833 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21834 if (!SWIG_IsOK(ecode2)) {
21835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21836 }
21837 arg2 = static_cast< int >(val2);
21838 if (arg1) (arg1)->m_wheelDelta = arg2;
21839
21840 resultobj = SWIG_Py_Void();
21841 return resultobj;
21842 fail:
21843 return NULL;
21844 }
21845
21846
21847 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21848 PyObject *resultobj = 0;
21849 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21850 int result;
21851 void *argp1 = 0 ;
21852 int res1 = 0 ;
21853 PyObject *swig_obj[1] ;
21854
21855 if (!args) SWIG_fail;
21856 swig_obj[0] = args;
21857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21858 if (!SWIG_IsOK(res1)) {
21859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21860 }
21861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21862 result = (int) ((arg1)->m_wheelDelta);
21863 resultobj = SWIG_From_int(static_cast< int >(result));
21864 return resultobj;
21865 fail:
21866 return NULL;
21867 }
21868
21869
21870 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 PyObject *resultobj = 0;
21872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21873 int arg2 ;
21874 void *argp1 = 0 ;
21875 int res1 = 0 ;
21876 int val2 ;
21877 int ecode2 = 0 ;
21878 PyObject *swig_obj[2] ;
21879
21880 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21882 if (!SWIG_IsOK(res1)) {
21883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21884 }
21885 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21886 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21887 if (!SWIG_IsOK(ecode2)) {
21888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21889 }
21890 arg2 = static_cast< int >(val2);
21891 if (arg1) (arg1)->m_linesPerAction = arg2;
21892
21893 resultobj = SWIG_Py_Void();
21894 return resultobj;
21895 fail:
21896 return NULL;
21897 }
21898
21899
21900 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 PyObject *resultobj = 0;
21902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21903 int result;
21904 void *argp1 = 0 ;
21905 int res1 = 0 ;
21906 PyObject *swig_obj[1] ;
21907
21908 if (!args) SWIG_fail;
21909 swig_obj[0] = args;
21910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21911 if (!SWIG_IsOK(res1)) {
21912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21913 }
21914 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21915 result = (int) ((arg1)->m_linesPerAction);
21916 resultobj = SWIG_From_int(static_cast< int >(result));
21917 return resultobj;
21918 fail:
21919 return NULL;
21920 }
21921
21922
21923 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21924 PyObject *obj;
21925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21926 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21927 return SWIG_Py_Void();
21928 }
21929
21930 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21931 return SWIG_Python_InitShadowInstance(args);
21932 }
21933
21934 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21935 PyObject *resultobj = 0;
21936 int arg1 = (int) 0 ;
21937 int arg2 = (int) 0 ;
21938 wxSetCursorEvent *result = 0 ;
21939 int val1 ;
21940 int ecode1 = 0 ;
21941 int val2 ;
21942 int ecode2 = 0 ;
21943 PyObject * obj0 = 0 ;
21944 PyObject * obj1 = 0 ;
21945 char * kwnames[] = {
21946 (char *) "x",(char *) "y", NULL
21947 };
21948
21949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21950 if (obj0) {
21951 ecode1 = SWIG_AsVal_int(obj0, &val1);
21952 if (!SWIG_IsOK(ecode1)) {
21953 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21954 }
21955 arg1 = static_cast< int >(val1);
21956 }
21957 if (obj1) {
21958 ecode2 = SWIG_AsVal_int(obj1, &val2);
21959 if (!SWIG_IsOK(ecode2)) {
21960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21961 }
21962 arg2 = static_cast< int >(val2);
21963 }
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21967 wxPyEndAllowThreads(__tstate);
21968 if (PyErr_Occurred()) SWIG_fail;
21969 }
21970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21971 return resultobj;
21972 fail:
21973 return NULL;
21974 }
21975
21976
21977 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21978 PyObject *resultobj = 0;
21979 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21980 int result;
21981 void *argp1 = 0 ;
21982 int res1 = 0 ;
21983 PyObject *swig_obj[1] ;
21984
21985 if (!args) SWIG_fail;
21986 swig_obj[0] = args;
21987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21988 if (!SWIG_IsOK(res1)) {
21989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21990 }
21991 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21995 wxPyEndAllowThreads(__tstate);
21996 if (PyErr_Occurred()) SWIG_fail;
21997 }
21998 resultobj = SWIG_From_int(static_cast< int >(result));
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22006 PyObject *resultobj = 0;
22007 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22008 int result;
22009 void *argp1 = 0 ;
22010 int res1 = 0 ;
22011 PyObject *swig_obj[1] ;
22012
22013 if (!args) SWIG_fail;
22014 swig_obj[0] = args;
22015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22018 }
22019 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 resultobj = SWIG_From_int(static_cast< int >(result));
22027 return resultobj;
22028 fail:
22029 return NULL;
22030 }
22031
22032
22033 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22034 PyObject *resultobj = 0;
22035 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22036 wxCursor *arg2 = 0 ;
22037 void *argp1 = 0 ;
22038 int res1 = 0 ;
22039 void *argp2 = 0 ;
22040 int res2 = 0 ;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 char * kwnames[] = {
22044 (char *) "self",(char *) "cursor", NULL
22045 };
22046
22047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22049 if (!SWIG_IsOK(res1)) {
22050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22051 }
22052 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22054 if (!SWIG_IsOK(res2)) {
22055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22056 }
22057 if (!argp2) {
22058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22059 }
22060 arg2 = reinterpret_cast< wxCursor * >(argp2);
22061 {
22062 PyThreadState* __tstate = wxPyBeginAllowThreads();
22063 (arg1)->SetCursor((wxCursor const &)*arg2);
22064 wxPyEndAllowThreads(__tstate);
22065 if (PyErr_Occurred()) SWIG_fail;
22066 }
22067 resultobj = SWIG_Py_Void();
22068 return resultobj;
22069 fail:
22070 return NULL;
22071 }
22072
22073
22074 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22075 PyObject *resultobj = 0;
22076 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22077 wxCursor *result = 0 ;
22078 void *argp1 = 0 ;
22079 int res1 = 0 ;
22080 PyObject *swig_obj[1] ;
22081
22082 if (!args) SWIG_fail;
22083 swig_obj[0] = args;
22084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22085 if (!SWIG_IsOK(res1)) {
22086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22087 }
22088 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22089 {
22090 PyThreadState* __tstate = wxPyBeginAllowThreads();
22091 {
22092 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22093 result = (wxCursor *) &_result_ref;
22094 }
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 {
22099 wxCursor* resultptr = new wxCursor(*result);
22100 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22101 }
22102 return resultobj;
22103 fail:
22104 return NULL;
22105 }
22106
22107
22108 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22109 PyObject *resultobj = 0;
22110 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22111 bool result;
22112 void *argp1 = 0 ;
22113 int res1 = 0 ;
22114 PyObject *swig_obj[1] ;
22115
22116 if (!args) SWIG_fail;
22117 swig_obj[0] = args;
22118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22119 if (!SWIG_IsOK(res1)) {
22120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22121 }
22122 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 {
22130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22131 }
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22139 PyObject *obj;
22140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22141 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22142 return SWIG_Py_Void();
22143 }
22144
22145 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22146 return SWIG_Python_InitShadowInstance(args);
22147 }
22148
22149 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22150 PyObject *resultobj = 0;
22151 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22152 wxKeyEvent *result = 0 ;
22153 int val1 ;
22154 int ecode1 = 0 ;
22155 PyObject * obj0 = 0 ;
22156 char * kwnames[] = {
22157 (char *) "eventType", NULL
22158 };
22159
22160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22161 if (obj0) {
22162 ecode1 = SWIG_AsVal_int(obj0, &val1);
22163 if (!SWIG_IsOK(ecode1)) {
22164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22165 }
22166 arg1 = static_cast< wxEventType >(val1);
22167 }
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22184 int result;
22185 void *argp1 = 0 ;
22186 int res1 = 0 ;
22187 PyObject *swig_obj[1] ;
22188
22189 if (!args) SWIG_fail;
22190 swig_obj[0] = args;
22191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22192 if (!SWIG_IsOK(res1)) {
22193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22194 }
22195 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 resultobj = SWIG_From_int(static_cast< int >(result));
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 PyObject *resultobj = 0;
22211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22212 bool result;
22213 void *argp1 = 0 ;
22214 int res1 = 0 ;
22215 PyObject *swig_obj[1] ;
22216
22217 if (!args) SWIG_fail;
22218 swig_obj[0] = args;
22219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22220 if (!SWIG_IsOK(res1)) {
22221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22222 }
22223 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22224 {
22225 PyThreadState* __tstate = wxPyBeginAllowThreads();
22226 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22227 wxPyEndAllowThreads(__tstate);
22228 if (PyErr_Occurred()) SWIG_fail;
22229 }
22230 {
22231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22232 }
22233 return resultobj;
22234 fail:
22235 return NULL;
22236 }
22237
22238
22239 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22240 PyObject *resultobj = 0;
22241 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22242 bool result;
22243 void *argp1 = 0 ;
22244 int res1 = 0 ;
22245 PyObject *swig_obj[1] ;
22246
22247 if (!args) SWIG_fail;
22248 swig_obj[0] = args;
22249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22250 if (!SWIG_IsOK(res1)) {
22251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22252 }
22253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22254 {
22255 PyThreadState* __tstate = wxPyBeginAllowThreads();
22256 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 {
22261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22262 }
22263 return resultobj;
22264 fail:
22265 return NULL;
22266 }
22267
22268
22269 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22270 PyObject *resultobj = 0;
22271 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22272 bool result;
22273 void *argp1 = 0 ;
22274 int res1 = 0 ;
22275 PyObject *swig_obj[1] ;
22276
22277 if (!args) SWIG_fail;
22278 swig_obj[0] = args;
22279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22280 if (!SWIG_IsOK(res1)) {
22281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22282 }
22283 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22300 PyObject *resultobj = 0;
22301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22302 bool result;
22303 void *argp1 = 0 ;
22304 int res1 = 0 ;
22305 PyObject *swig_obj[1] ;
22306
22307 if (!args) SWIG_fail;
22308 swig_obj[0] = args;
22309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22310 if (!SWIG_IsOK(res1)) {
22311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22312 }
22313 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22317 wxPyEndAllowThreads(__tstate);
22318 if (PyErr_Occurred()) SWIG_fail;
22319 }
22320 {
22321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22322 }
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22330 PyObject *resultobj = 0;
22331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22332 bool result;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 PyObject *swig_obj[1] ;
22336
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 {
22351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22352 }
22353 return resultobj;
22354 fail:
22355 return NULL;
22356 }
22357
22358
22359 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22360 PyObject *resultobj = 0;
22361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22362 bool result;
22363 void *argp1 = 0 ;
22364 int res1 = 0 ;
22365 PyObject *swig_obj[1] ;
22366
22367 if (!args) SWIG_fail;
22368 swig_obj[0] = args;
22369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22370 if (!SWIG_IsOK(res1)) {
22371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22372 }
22373 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 {
22381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22382 }
22383 return resultobj;
22384 fail:
22385 return NULL;
22386 }
22387
22388
22389 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22390 PyObject *resultobj = 0;
22391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22392 int result;
22393 void *argp1 = 0 ;
22394 int res1 = 0 ;
22395 PyObject *swig_obj[1] ;
22396
22397 if (!args) SWIG_fail;
22398 swig_obj[0] = args;
22399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22402 }
22403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22407 wxPyEndAllowThreads(__tstate);
22408 if (PyErr_Occurred()) SWIG_fail;
22409 }
22410 resultobj = SWIG_From_int(static_cast< int >(result));
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(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_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22430 }
22431 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
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_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22446 PyObject *resultobj = 0;
22447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22448 int arg2 ;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 int val2 ;
22452 int ecode2 = 0 ;
22453 PyObject * obj0 = 0 ;
22454 PyObject * obj1 = 0 ;
22455 char * kwnames[] = {
22456 (char *) "self",(char *) "uniChar", NULL
22457 };
22458
22459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22461 if (!SWIG_IsOK(res1)) {
22462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22463 }
22464 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22465 ecode2 = SWIG_AsVal_int(obj1, &val2);
22466 if (!SWIG_IsOK(ecode2)) {
22467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22468 }
22469 arg2 = static_cast< int >(val2);
22470 {
22471 PyThreadState* __tstate = wxPyBeginAllowThreads();
22472 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22473 wxPyEndAllowThreads(__tstate);
22474 if (PyErr_Occurred()) SWIG_fail;
22475 }
22476 resultobj = SWIG_Py_Void();
22477 return resultobj;
22478 fail:
22479 return NULL;
22480 }
22481
22482
22483 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22484 PyObject *resultobj = 0;
22485 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22486 unsigned int result;
22487 void *argp1 = 0 ;
22488 int res1 = 0 ;
22489 PyObject *swig_obj[1] ;
22490
22491 if (!args) SWIG_fail;
22492 swig_obj[0] = args;
22493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22494 if (!SWIG_IsOK(res1)) {
22495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22496 }
22497 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22498 {
22499 PyThreadState* __tstate = wxPyBeginAllowThreads();
22500 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22501 wxPyEndAllowThreads(__tstate);
22502 if (PyErr_Occurred()) SWIG_fail;
22503 }
22504 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22505 return resultobj;
22506 fail:
22507 return NULL;
22508 }
22509
22510
22511 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22512 PyObject *resultobj = 0;
22513 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22514 unsigned int result;
22515 void *argp1 = 0 ;
22516 int res1 = 0 ;
22517 PyObject *swig_obj[1] ;
22518
22519 if (!args) SWIG_fail;
22520 swig_obj[0] = args;
22521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22522 if (!SWIG_IsOK(res1)) {
22523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22524 }
22525 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22529 wxPyEndAllowThreads(__tstate);
22530 if (PyErr_Occurred()) SWIG_fail;
22531 }
22532 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22540 PyObject *resultobj = 0;
22541 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22542 wxPoint result;
22543 void *argp1 = 0 ;
22544 int res1 = 0 ;
22545 PyObject *swig_obj[1] ;
22546
22547 if (!args) SWIG_fail;
22548 swig_obj[0] = args;
22549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22550 if (!SWIG_IsOK(res1)) {
22551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22552 }
22553 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 result = (arg1)->GetPosition();
22557 wxPyEndAllowThreads(__tstate);
22558 if (PyErr_Occurred()) SWIG_fail;
22559 }
22560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22568 PyObject *resultobj = 0;
22569 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22570 long *arg2 = (long *) 0 ;
22571 long *arg3 = (long *) 0 ;
22572 void *argp1 = 0 ;
22573 int res1 = 0 ;
22574 long temp2 ;
22575 int res2 = SWIG_TMPOBJ ;
22576 long temp3 ;
22577 int res3 = SWIG_TMPOBJ ;
22578 PyObject *swig_obj[1] ;
22579
22580 arg2 = &temp2;
22581 arg3 = &temp3;
22582 if (!args) SWIG_fail;
22583 swig_obj[0] = args;
22584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22585 if (!SWIG_IsOK(res1)) {
22586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22587 }
22588 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 (arg1)->GetPosition(arg2,arg3);
22592 wxPyEndAllowThreads(__tstate);
22593 if (PyErr_Occurred()) SWIG_fail;
22594 }
22595 resultobj = SWIG_Py_Void();
22596 if (SWIG_IsTmpObj(res2)) {
22597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22598 } else {
22599 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22601 }
22602 if (SWIG_IsTmpObj(res3)) {
22603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22604 } else {
22605 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22607 }
22608 return resultobj;
22609 fail:
22610 return NULL;
22611 }
22612
22613
22614 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615 PyObject *resultobj = 0;
22616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22617 int result;
22618 void *argp1 = 0 ;
22619 int res1 = 0 ;
22620 PyObject *swig_obj[1] ;
22621
22622 if (!args) SWIG_fail;
22623 swig_obj[0] = args;
22624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22625 if (!SWIG_IsOK(res1)) {
22626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22627 }
22628 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22629 {
22630 PyThreadState* __tstate = wxPyBeginAllowThreads();
22631 result = (int)((wxKeyEvent const *)arg1)->GetX();
22632 wxPyEndAllowThreads(__tstate);
22633 if (PyErr_Occurred()) SWIG_fail;
22634 }
22635 resultobj = SWIG_From_int(static_cast< int >(result));
22636 return resultobj;
22637 fail:
22638 return NULL;
22639 }
22640
22641
22642 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22643 PyObject *resultobj = 0;
22644 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22645 int result;
22646 void *argp1 = 0 ;
22647 int res1 = 0 ;
22648 PyObject *swig_obj[1] ;
22649
22650 if (!args) SWIG_fail;
22651 swig_obj[0] = args;
22652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22653 if (!SWIG_IsOK(res1)) {
22654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22655 }
22656 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22657 {
22658 PyThreadState* __tstate = wxPyBeginAllowThreads();
22659 result = (int)((wxKeyEvent const *)arg1)->GetY();
22660 wxPyEndAllowThreads(__tstate);
22661 if (PyErr_Occurred()) SWIG_fail;
22662 }
22663 resultobj = SWIG_From_int(static_cast< int >(result));
22664 return resultobj;
22665 fail:
22666 return NULL;
22667 }
22668
22669
22670 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22671 PyObject *resultobj = 0;
22672 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22673 int arg2 ;
22674 void *argp1 = 0 ;
22675 int res1 = 0 ;
22676 int val2 ;
22677 int ecode2 = 0 ;
22678 PyObject *swig_obj[2] ;
22679
22680 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22682 if (!SWIG_IsOK(res1)) {
22683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22684 }
22685 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22686 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22687 if (!SWIG_IsOK(ecode2)) {
22688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22689 }
22690 arg2 = static_cast< int >(val2);
22691 if (arg1) (arg1)->m_x = arg2;
22692
22693 resultobj = SWIG_Py_Void();
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22701 PyObject *resultobj = 0;
22702 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22703 int result;
22704 void *argp1 = 0 ;
22705 int res1 = 0 ;
22706 PyObject *swig_obj[1] ;
22707
22708 if (!args) SWIG_fail;
22709 swig_obj[0] = args;
22710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22711 if (!SWIG_IsOK(res1)) {
22712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22713 }
22714 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22715 result = (int) ((arg1)->m_x);
22716 resultobj = SWIG_From_int(static_cast< int >(result));
22717 return resultobj;
22718 fail:
22719 return NULL;
22720 }
22721
22722
22723 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22724 PyObject *resultobj = 0;
22725 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22726 int arg2 ;
22727 void *argp1 = 0 ;
22728 int res1 = 0 ;
22729 int val2 ;
22730 int ecode2 = 0 ;
22731 PyObject *swig_obj[2] ;
22732
22733 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22735 if (!SWIG_IsOK(res1)) {
22736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22737 }
22738 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22739 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22740 if (!SWIG_IsOK(ecode2)) {
22741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22742 }
22743 arg2 = static_cast< int >(val2);
22744 if (arg1) (arg1)->m_y = arg2;
22745
22746 resultobj = SWIG_Py_Void();
22747 return resultobj;
22748 fail:
22749 return NULL;
22750 }
22751
22752
22753 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22754 PyObject *resultobj = 0;
22755 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22756 int result;
22757 void *argp1 = 0 ;
22758 int res1 = 0 ;
22759 PyObject *swig_obj[1] ;
22760
22761 if (!args) SWIG_fail;
22762 swig_obj[0] = args;
22763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22764 if (!SWIG_IsOK(res1)) {
22765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22766 }
22767 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22768 result = (int) ((arg1)->m_y);
22769 resultobj = SWIG_From_int(static_cast< int >(result));
22770 return resultobj;
22771 fail:
22772 return NULL;
22773 }
22774
22775
22776 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22777 PyObject *resultobj = 0;
22778 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22779 long arg2 ;
22780 void *argp1 = 0 ;
22781 int res1 = 0 ;
22782 long val2 ;
22783 int ecode2 = 0 ;
22784 PyObject *swig_obj[2] ;
22785
22786 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22788 if (!SWIG_IsOK(res1)) {
22789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22790 }
22791 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22792 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22793 if (!SWIG_IsOK(ecode2)) {
22794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22795 }
22796 arg2 = static_cast< long >(val2);
22797 if (arg1) (arg1)->m_keyCode = arg2;
22798
22799 resultobj = SWIG_Py_Void();
22800 return resultobj;
22801 fail:
22802 return NULL;
22803 }
22804
22805
22806 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22807 PyObject *resultobj = 0;
22808 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22809 long result;
22810 void *argp1 = 0 ;
22811 int res1 = 0 ;
22812 PyObject *swig_obj[1] ;
22813
22814 if (!args) SWIG_fail;
22815 swig_obj[0] = args;
22816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22817 if (!SWIG_IsOK(res1)) {
22818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22819 }
22820 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22821 result = (long) ((arg1)->m_keyCode);
22822 resultobj = SWIG_From_long(static_cast< long >(result));
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22830 PyObject *resultobj = 0;
22831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22832 bool arg2 ;
22833 void *argp1 = 0 ;
22834 int res1 = 0 ;
22835 bool val2 ;
22836 int ecode2 = 0 ;
22837 PyObject *swig_obj[2] ;
22838
22839 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22841 if (!SWIG_IsOK(res1)) {
22842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22843 }
22844 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22845 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22846 if (!SWIG_IsOK(ecode2)) {
22847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22848 }
22849 arg2 = static_cast< bool >(val2);
22850 if (arg1) (arg1)->m_controlDown = arg2;
22851
22852 resultobj = SWIG_Py_Void();
22853 return resultobj;
22854 fail:
22855 return NULL;
22856 }
22857
22858
22859 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22860 PyObject *resultobj = 0;
22861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22862 bool result;
22863 void *argp1 = 0 ;
22864 int res1 = 0 ;
22865 PyObject *swig_obj[1] ;
22866
22867 if (!args) SWIG_fail;
22868 swig_obj[0] = args;
22869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22870 if (!SWIG_IsOK(res1)) {
22871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22872 }
22873 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22874 result = (bool) ((arg1)->m_controlDown);
22875 {
22876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22877 }
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885 PyObject *resultobj = 0;
22886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22887 bool arg2 ;
22888 void *argp1 = 0 ;
22889 int res1 = 0 ;
22890 bool val2 ;
22891 int ecode2 = 0 ;
22892 PyObject *swig_obj[2] ;
22893
22894 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22896 if (!SWIG_IsOK(res1)) {
22897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22898 }
22899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22900 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22901 if (!SWIG_IsOK(ecode2)) {
22902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22903 }
22904 arg2 = static_cast< bool >(val2);
22905 if (arg1) (arg1)->m_shiftDown = arg2;
22906
22907 resultobj = SWIG_Py_Void();
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22915 PyObject *resultobj = 0;
22916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22917 bool result;
22918 void *argp1 = 0 ;
22919 int res1 = 0 ;
22920 PyObject *swig_obj[1] ;
22921
22922 if (!args) SWIG_fail;
22923 swig_obj[0] = args;
22924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22925 if (!SWIG_IsOK(res1)) {
22926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22927 }
22928 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22929 result = (bool) ((arg1)->m_shiftDown);
22930 {
22931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22932 }
22933 return resultobj;
22934 fail:
22935 return NULL;
22936 }
22937
22938
22939 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22940 PyObject *resultobj = 0;
22941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22942 bool arg2 ;
22943 void *argp1 = 0 ;
22944 int res1 = 0 ;
22945 bool val2 ;
22946 int ecode2 = 0 ;
22947 PyObject *swig_obj[2] ;
22948
22949 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22951 if (!SWIG_IsOK(res1)) {
22952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22953 }
22954 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22955 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22956 if (!SWIG_IsOK(ecode2)) {
22957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22958 }
22959 arg2 = static_cast< bool >(val2);
22960 if (arg1) (arg1)->m_altDown = arg2;
22961
22962 resultobj = SWIG_Py_Void();
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22970 PyObject *resultobj = 0;
22971 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22972 bool result;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 PyObject *swig_obj[1] ;
22976
22977 if (!args) SWIG_fail;
22978 swig_obj[0] = args;
22979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22980 if (!SWIG_IsOK(res1)) {
22981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22982 }
22983 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22984 result = (bool) ((arg1)->m_altDown);
22985 {
22986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22987 }
22988 return resultobj;
22989 fail:
22990 return NULL;
22991 }
22992
22993
22994 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22995 PyObject *resultobj = 0;
22996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22997 bool arg2 ;
22998 void *argp1 = 0 ;
22999 int res1 = 0 ;
23000 bool val2 ;
23001 int ecode2 = 0 ;
23002 PyObject *swig_obj[2] ;
23003
23004 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23006 if (!SWIG_IsOK(res1)) {
23007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23008 }
23009 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23010 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23011 if (!SWIG_IsOK(ecode2)) {
23012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23013 }
23014 arg2 = static_cast< bool >(val2);
23015 if (arg1) (arg1)->m_metaDown = arg2;
23016
23017 resultobj = SWIG_Py_Void();
23018 return resultobj;
23019 fail:
23020 return NULL;
23021 }
23022
23023
23024 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23025 PyObject *resultobj = 0;
23026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23027 bool result;
23028 void *argp1 = 0 ;
23029 int res1 = 0 ;
23030 PyObject *swig_obj[1] ;
23031
23032 if (!args) SWIG_fail;
23033 swig_obj[0] = args;
23034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23035 if (!SWIG_IsOK(res1)) {
23036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23037 }
23038 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23039 result = (bool) ((arg1)->m_metaDown);
23040 {
23041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23042 }
23043 return resultobj;
23044 fail:
23045 return NULL;
23046 }
23047
23048
23049 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23050 PyObject *resultobj = 0;
23051 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23052 bool arg2 ;
23053 void *argp1 = 0 ;
23054 int res1 = 0 ;
23055 bool val2 ;
23056 int ecode2 = 0 ;
23057 PyObject *swig_obj[2] ;
23058
23059 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23061 if (!SWIG_IsOK(res1)) {
23062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23063 }
23064 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23065 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23066 if (!SWIG_IsOK(ecode2)) {
23067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23068 }
23069 arg2 = static_cast< bool >(val2);
23070 if (arg1) (arg1)->m_scanCode = arg2;
23071
23072 resultobj = SWIG_Py_Void();
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *resultobj = 0;
23081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23082 bool result;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 PyObject *swig_obj[1] ;
23086
23087 if (!args) SWIG_fail;
23088 swig_obj[0] = args;
23089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23092 }
23093 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23094 result = (bool) ((arg1)->m_scanCode);
23095 {
23096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23097 }
23098 return resultobj;
23099 fail:
23100 return NULL;
23101 }
23102
23103
23104 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23105 PyObject *resultobj = 0;
23106 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23107 unsigned int arg2 ;
23108 void *argp1 = 0 ;
23109 int res1 = 0 ;
23110 unsigned int val2 ;
23111 int ecode2 = 0 ;
23112 PyObject *swig_obj[2] ;
23113
23114 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23116 if (!SWIG_IsOK(res1)) {
23117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23118 }
23119 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23120 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23121 if (!SWIG_IsOK(ecode2)) {
23122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23123 }
23124 arg2 = static_cast< unsigned int >(val2);
23125 if (arg1) (arg1)->m_rawCode = arg2;
23126
23127 resultobj = SWIG_Py_Void();
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23135 PyObject *resultobj = 0;
23136 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23137 unsigned int result;
23138 void *argp1 = 0 ;
23139 int res1 = 0 ;
23140 PyObject *swig_obj[1] ;
23141
23142 if (!args) SWIG_fail;
23143 swig_obj[0] = args;
23144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23145 if (!SWIG_IsOK(res1)) {
23146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23147 }
23148 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23149 result = (unsigned int) ((arg1)->m_rawCode);
23150 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23158 PyObject *resultobj = 0;
23159 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23160 unsigned int arg2 ;
23161 void *argp1 = 0 ;
23162 int res1 = 0 ;
23163 unsigned int val2 ;
23164 int ecode2 = 0 ;
23165 PyObject *swig_obj[2] ;
23166
23167 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23169 if (!SWIG_IsOK(res1)) {
23170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23171 }
23172 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23173 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23174 if (!SWIG_IsOK(ecode2)) {
23175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23176 }
23177 arg2 = static_cast< unsigned int >(val2);
23178 if (arg1) (arg1)->m_rawFlags = arg2;
23179
23180 resultobj = SWIG_Py_Void();
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23188 PyObject *resultobj = 0;
23189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23190 unsigned int result;
23191 void *argp1 = 0 ;
23192 int res1 = 0 ;
23193 PyObject *swig_obj[1] ;
23194
23195 if (!args) SWIG_fail;
23196 swig_obj[0] = args;
23197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23198 if (!SWIG_IsOK(res1)) {
23199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23200 }
23201 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23202 result = (unsigned int) ((arg1)->m_rawFlags);
23203 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23211 PyObject *obj;
23212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23213 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23214 return SWIG_Py_Void();
23215 }
23216
23217 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23218 return SWIG_Python_InitShadowInstance(args);
23219 }
23220
23221 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23222 PyObject *resultobj = 0;
23223 wxSize const &arg1_defvalue = wxDefaultSize ;
23224 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23225 int arg2 = (int) 0 ;
23226 wxSizeEvent *result = 0 ;
23227 wxSize temp1 ;
23228 int val2 ;
23229 int ecode2 = 0 ;
23230 PyObject * obj0 = 0 ;
23231 PyObject * obj1 = 0 ;
23232 char * kwnames[] = {
23233 (char *) "sz",(char *) "winid", NULL
23234 };
23235
23236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23237 if (obj0) {
23238 {
23239 arg1 = &temp1;
23240 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23241 }
23242 }
23243 if (obj1) {
23244 ecode2 = SWIG_AsVal_int(obj1, &val2);
23245 if (!SWIG_IsOK(ecode2)) {
23246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23247 }
23248 arg2 = static_cast< int >(val2);
23249 }
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23257 return resultobj;
23258 fail:
23259 return NULL;
23260 }
23261
23262
23263 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23264 PyObject *resultobj = 0;
23265 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23266 wxSize result;
23267 void *argp1 = 0 ;
23268 int res1 = 0 ;
23269 PyObject *swig_obj[1] ;
23270
23271 if (!args) SWIG_fail;
23272 swig_obj[0] = args;
23273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23274 if (!SWIG_IsOK(res1)) {
23275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23276 }
23277 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = ((wxSizeEvent const *)arg1)->GetSize();
23281 wxPyEndAllowThreads(__tstate);
23282 if (PyErr_Occurred()) SWIG_fail;
23283 }
23284 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23292 PyObject *resultobj = 0;
23293 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23294 wxRect result;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 PyObject *swig_obj[1] ;
23298
23299 if (!args) SWIG_fail;
23300 swig_obj[0] = args;
23301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23302 if (!SWIG_IsOK(res1)) {
23303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23304 }
23305 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = ((wxSizeEvent const *)arg1)->GetRect();
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23313 return resultobj;
23314 fail:
23315 return NULL;
23316 }
23317
23318
23319 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23320 PyObject *resultobj = 0;
23321 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23322 wxRect arg2 ;
23323 void *argp1 = 0 ;
23324 int res1 = 0 ;
23325 void *argp2 ;
23326 int res2 = 0 ;
23327 PyObject * obj0 = 0 ;
23328 PyObject * obj1 = 0 ;
23329 char * kwnames[] = {
23330 (char *) "self",(char *) "rect", NULL
23331 };
23332
23333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23335 if (!SWIG_IsOK(res1)) {
23336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23337 }
23338 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23339 {
23340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23341 if (!SWIG_IsOK(res2)) {
23342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23343 }
23344 if (!argp2) {
23345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23346 } else {
23347 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23348 arg2 = *temp;
23349 if (SWIG_IsNewObj(res2)) delete temp;
23350 }
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 (arg1)->SetRect(arg2);
23355 wxPyEndAllowThreads(__tstate);
23356 if (PyErr_Occurred()) SWIG_fail;
23357 }
23358 resultobj = SWIG_Py_Void();
23359 return resultobj;
23360 fail:
23361 return NULL;
23362 }
23363
23364
23365 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23366 PyObject *resultobj = 0;
23367 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23368 wxSize arg2 ;
23369 void *argp1 = 0 ;
23370 int res1 = 0 ;
23371 void *argp2 ;
23372 int res2 = 0 ;
23373 PyObject * obj0 = 0 ;
23374 PyObject * obj1 = 0 ;
23375 char * kwnames[] = {
23376 (char *) "self",(char *) "size", NULL
23377 };
23378
23379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23381 if (!SWIG_IsOK(res1)) {
23382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23383 }
23384 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23385 {
23386 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23387 if (!SWIG_IsOK(res2)) {
23388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23389 }
23390 if (!argp2) {
23391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23392 } else {
23393 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23394 arg2 = *temp;
23395 if (SWIG_IsNewObj(res2)) delete temp;
23396 }
23397 }
23398 {
23399 PyThreadState* __tstate = wxPyBeginAllowThreads();
23400 wxSizeEvent_SetSize(arg1,arg2);
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 resultobj = SWIG_Py_Void();
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23414 wxSize *arg2 = (wxSize *) 0 ;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 void *argp2 = 0 ;
23418 int res2 = 0 ;
23419 PyObject *swig_obj[2] ;
23420
23421 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23423 if (!SWIG_IsOK(res1)) {
23424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23425 }
23426 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23427 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23428 if (!SWIG_IsOK(res2)) {
23429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23430 }
23431 arg2 = reinterpret_cast< wxSize * >(argp2);
23432 if (arg1) (arg1)->m_size = *arg2;
23433
23434 resultobj = SWIG_Py_Void();
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *resultobj = 0;
23443 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23444 wxSize *result = 0 ;
23445 void *argp1 = 0 ;
23446 int res1 = 0 ;
23447 PyObject *swig_obj[1] ;
23448
23449 if (!args) SWIG_fail;
23450 swig_obj[0] = args;
23451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23452 if (!SWIG_IsOK(res1)) {
23453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23454 }
23455 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23456 result = (wxSize *)& ((arg1)->m_size);
23457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23458 return resultobj;
23459 fail:
23460 return NULL;
23461 }
23462
23463
23464 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23465 PyObject *resultobj = 0;
23466 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23467 wxRect *arg2 = (wxRect *) 0 ;
23468 void *argp1 = 0 ;
23469 int res1 = 0 ;
23470 void *argp2 = 0 ;
23471 int res2 = 0 ;
23472 PyObject *swig_obj[2] ;
23473
23474 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23476 if (!SWIG_IsOK(res1)) {
23477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23478 }
23479 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23480 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23481 if (!SWIG_IsOK(res2)) {
23482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23483 }
23484 arg2 = reinterpret_cast< wxRect * >(argp2);
23485 if (arg1) (arg1)->m_rect = *arg2;
23486
23487 resultobj = SWIG_Py_Void();
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23495 PyObject *resultobj = 0;
23496 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23497 wxRect *result = 0 ;
23498 void *argp1 = 0 ;
23499 int res1 = 0 ;
23500 PyObject *swig_obj[1] ;
23501
23502 if (!args) SWIG_fail;
23503 swig_obj[0] = args;
23504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23505 if (!SWIG_IsOK(res1)) {
23506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23507 }
23508 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23509 result = (wxRect *)& ((arg1)->m_rect);
23510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23518 PyObject *obj;
23519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23520 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23521 return SWIG_Py_Void();
23522 }
23523
23524 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23525 return SWIG_Python_InitShadowInstance(args);
23526 }
23527
23528 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23529 PyObject *resultobj = 0;
23530 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23531 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23532 int arg2 = (int) 0 ;
23533 wxMoveEvent *result = 0 ;
23534 wxPoint temp1 ;
23535 int val2 ;
23536 int ecode2 = 0 ;
23537 PyObject * obj0 = 0 ;
23538 PyObject * obj1 = 0 ;
23539 char * kwnames[] = {
23540 (char *) "pos",(char *) "winid", NULL
23541 };
23542
23543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23544 if (obj0) {
23545 {
23546 arg1 = &temp1;
23547 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23548 }
23549 }
23550 if (obj1) {
23551 ecode2 = SWIG_AsVal_int(obj1, &val2);
23552 if (!SWIG_IsOK(ecode2)) {
23553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23554 }
23555 arg2 = static_cast< int >(val2);
23556 }
23557 {
23558 PyThreadState* __tstate = wxPyBeginAllowThreads();
23559 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23564 return resultobj;
23565 fail:
23566 return NULL;
23567 }
23568
23569
23570 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23571 PyObject *resultobj = 0;
23572 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23573 wxPoint result;
23574 void *argp1 = 0 ;
23575 int res1 = 0 ;
23576 PyObject *swig_obj[1] ;
23577
23578 if (!args) SWIG_fail;
23579 swig_obj[0] = args;
23580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23581 if (!SWIG_IsOK(res1)) {
23582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23583 }
23584 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23585 {
23586 PyThreadState* __tstate = wxPyBeginAllowThreads();
23587 result = ((wxMoveEvent const *)arg1)->GetPosition();
23588 wxPyEndAllowThreads(__tstate);
23589 if (PyErr_Occurred()) SWIG_fail;
23590 }
23591 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23592 return resultobj;
23593 fail:
23594 return NULL;
23595 }
23596
23597
23598 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23599 PyObject *resultobj = 0;
23600 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23601 wxRect result;
23602 void *argp1 = 0 ;
23603 int res1 = 0 ;
23604 PyObject *swig_obj[1] ;
23605
23606 if (!args) SWIG_fail;
23607 swig_obj[0] = args;
23608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23609 if (!SWIG_IsOK(res1)) {
23610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23611 }
23612 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23613 {
23614 PyThreadState* __tstate = wxPyBeginAllowThreads();
23615 result = ((wxMoveEvent const *)arg1)->GetRect();
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23627 PyObject *resultobj = 0;
23628 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23629 wxRect *arg2 = 0 ;
23630 void *argp1 = 0 ;
23631 int res1 = 0 ;
23632 wxRect temp2 ;
23633 PyObject * obj0 = 0 ;
23634 PyObject * obj1 = 0 ;
23635 char * kwnames[] = {
23636 (char *) "self",(char *) "rect", NULL
23637 };
23638
23639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23641 if (!SWIG_IsOK(res1)) {
23642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23643 }
23644 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23645 {
23646 arg2 = &temp2;
23647 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23648 }
23649 {
23650 PyThreadState* __tstate = wxPyBeginAllowThreads();
23651 (arg1)->SetRect((wxRect const &)*arg2);
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 resultobj = SWIG_Py_Void();
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23663 PyObject *resultobj = 0;
23664 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23665 wxPoint *arg2 = 0 ;
23666 void *argp1 = 0 ;
23667 int res1 = 0 ;
23668 wxPoint temp2 ;
23669 PyObject * obj0 = 0 ;
23670 PyObject * obj1 = 0 ;
23671 char * kwnames[] = {
23672 (char *) "self",(char *) "pos", NULL
23673 };
23674
23675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23677 if (!SWIG_IsOK(res1)) {
23678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23679 }
23680 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23681 {
23682 arg2 = &temp2;
23683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23684 }
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 (arg1)->SetPosition((wxPoint const &)*arg2);
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 resultobj = SWIG_Py_Void();
23692 return resultobj;
23693 fail:
23694 return NULL;
23695 }
23696
23697
23698 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23699 PyObject *obj;
23700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23701 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23702 return SWIG_Py_Void();
23703 }
23704
23705 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23706 return SWIG_Python_InitShadowInstance(args);
23707 }
23708
23709 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23710 PyObject *resultobj = 0;
23711 int arg1 = (int) 0 ;
23712 wxPaintEvent *result = 0 ;
23713 int val1 ;
23714 int ecode1 = 0 ;
23715 PyObject * obj0 = 0 ;
23716 char * kwnames[] = {
23717 (char *) "Id", NULL
23718 };
23719
23720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23721 if (obj0) {
23722 ecode1 = SWIG_AsVal_int(obj0, &val1);
23723 if (!SWIG_IsOK(ecode1)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23725 }
23726 arg1 = static_cast< int >(val1);
23727 }
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 PyObject *obj;
23743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23745 return SWIG_Py_Void();
23746 }
23747
23748 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23749 return SWIG_Python_InitShadowInstance(args);
23750 }
23751
23752 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj = 0;
23754 int arg1 = (int) 0 ;
23755 wxNcPaintEvent *result = 0 ;
23756 int val1 ;
23757 int ecode1 = 0 ;
23758 PyObject * obj0 = 0 ;
23759 char * kwnames[] = {
23760 (char *) "winid", NULL
23761 };
23762
23763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23764 if (obj0) {
23765 ecode1 = SWIG_AsVal_int(obj0, &val1);
23766 if (!SWIG_IsOK(ecode1)) {
23767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23768 }
23769 arg1 = static_cast< int >(val1);
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *obj;
23786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23787 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23788 return SWIG_Py_Void();
23789 }
23790
23791 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23792 return SWIG_Python_InitShadowInstance(args);
23793 }
23794
23795 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj = 0;
23797 int arg1 = (int) 0 ;
23798 wxDC *arg2 = (wxDC *) NULL ;
23799 wxEraseEvent *result = 0 ;
23800 int val1 ;
23801 int ecode1 = 0 ;
23802 void *argp2 = 0 ;
23803 int res2 = 0 ;
23804 PyObject * obj0 = 0 ;
23805 PyObject * obj1 = 0 ;
23806 char * kwnames[] = {
23807 (char *) "Id",(char *) "dc", NULL
23808 };
23809
23810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23811 if (obj0) {
23812 ecode1 = SWIG_AsVal_int(obj0, &val1);
23813 if (!SWIG_IsOK(ecode1)) {
23814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23815 }
23816 arg1 = static_cast< int >(val1);
23817 }
23818 if (obj1) {
23819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23820 if (!SWIG_IsOK(res2)) {
23821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23822 }
23823 arg2 = reinterpret_cast< wxDC * >(argp2);
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23828 wxPyEndAllowThreads(__tstate);
23829 if (PyErr_Occurred()) SWIG_fail;
23830 }
23831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23832 return resultobj;
23833 fail:
23834 return NULL;
23835 }
23836
23837
23838 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23839 PyObject *resultobj = 0;
23840 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23841 wxDC *result = 0 ;
23842 void *argp1 = 0 ;
23843 int res1 = 0 ;
23844 PyObject *swig_obj[1] ;
23845
23846 if (!args) SWIG_fail;
23847 swig_obj[0] = args;
23848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23849 if (!SWIG_IsOK(res1)) {
23850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23851 }
23852 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23853 {
23854 PyThreadState* __tstate = wxPyBeginAllowThreads();
23855 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 {
23860 resultobj = wxPyMake_wxObject(result, (bool)0);
23861 }
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *obj;
23870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23871 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23872 return SWIG_Py_Void();
23873 }
23874
23875 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 return SWIG_Python_InitShadowInstance(args);
23877 }
23878
23879 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj = 0;
23881 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23882 int arg2 = (int) 0 ;
23883 wxFocusEvent *result = 0 ;
23884 int val1 ;
23885 int ecode1 = 0 ;
23886 int val2 ;
23887 int ecode2 = 0 ;
23888 PyObject * obj0 = 0 ;
23889 PyObject * obj1 = 0 ;
23890 char * kwnames[] = {
23891 (char *) "type",(char *) "winid", NULL
23892 };
23893
23894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23895 if (obj0) {
23896 ecode1 = SWIG_AsVal_int(obj0, &val1);
23897 if (!SWIG_IsOK(ecode1)) {
23898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23899 }
23900 arg1 = static_cast< wxEventType >(val1);
23901 }
23902 if (obj1) {
23903 ecode2 = SWIG_AsVal_int(obj1, &val2);
23904 if (!SWIG_IsOK(ecode2)) {
23905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23906 }
23907 arg2 = static_cast< int >(val2);
23908 }
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23923 PyObject *resultobj = 0;
23924 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23925 wxWindow *result = 0 ;
23926 void *argp1 = 0 ;
23927 int res1 = 0 ;
23928 PyObject *swig_obj[1] ;
23929
23930 if (!args) SWIG_fail;
23931 swig_obj[0] = args;
23932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23933 if (!SWIG_IsOK(res1)) {
23934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23935 }
23936 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 {
23944 resultobj = wxPyMake_wxObject(result, (bool)0);
23945 }
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23953 PyObject *resultobj = 0;
23954 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23955 wxWindow *arg2 = (wxWindow *) 0 ;
23956 void *argp1 = 0 ;
23957 int res1 = 0 ;
23958 void *argp2 = 0 ;
23959 int res2 = 0 ;
23960 PyObject * obj0 = 0 ;
23961 PyObject * obj1 = 0 ;
23962 char * kwnames[] = {
23963 (char *) "self",(char *) "win", NULL
23964 };
23965
23966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23968 if (!SWIG_IsOK(res1)) {
23969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23970 }
23971 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23973 if (!SWIG_IsOK(res2)) {
23974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23975 }
23976 arg2 = reinterpret_cast< wxWindow * >(argp2);
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 (arg1)->SetWindow(arg2);
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 resultobj = SWIG_Py_Void();
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23991 PyObject *obj;
23992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23993 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23994 return SWIG_Py_Void();
23995 }
23996
23997 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23998 return SWIG_Python_InitShadowInstance(args);
23999 }
24000
24001 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24002 PyObject *resultobj = 0;
24003 wxWindow *arg1 = (wxWindow *) NULL ;
24004 wxChildFocusEvent *result = 0 ;
24005 void *argp1 = 0 ;
24006 int res1 = 0 ;
24007 PyObject * obj0 = 0 ;
24008 char * kwnames[] = {
24009 (char *) "win", NULL
24010 };
24011
24012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24013 if (obj0) {
24014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24017 }
24018 arg1 = reinterpret_cast< wxWindow * >(argp1);
24019 }
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24034 PyObject *resultobj = 0;
24035 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24036 wxWindow *result = 0 ;
24037 void *argp1 = 0 ;
24038 int res1 = 0 ;
24039 PyObject *swig_obj[1] ;
24040
24041 if (!args) SWIG_fail;
24042 swig_obj[0] = args;
24043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24044 if (!SWIG_IsOK(res1)) {
24045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24046 }
24047 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24048 {
24049 PyThreadState* __tstate = wxPyBeginAllowThreads();
24050 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24051 wxPyEndAllowThreads(__tstate);
24052 if (PyErr_Occurred()) SWIG_fail;
24053 }
24054 {
24055 resultobj = wxPyMake_wxObject(result, (bool)0);
24056 }
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24064 PyObject *obj;
24065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24066 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24067 return SWIG_Py_Void();
24068 }
24069
24070 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24071 return SWIG_Python_InitShadowInstance(args);
24072 }
24073
24074 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24075 PyObject *resultobj = 0;
24076 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24077 bool arg2 = (bool) true ;
24078 int arg3 = (int) 0 ;
24079 wxActivateEvent *result = 0 ;
24080 int val1 ;
24081 int ecode1 = 0 ;
24082 bool val2 ;
24083 int ecode2 = 0 ;
24084 int val3 ;
24085 int ecode3 = 0 ;
24086 PyObject * obj0 = 0 ;
24087 PyObject * obj1 = 0 ;
24088 PyObject * obj2 = 0 ;
24089 char * kwnames[] = {
24090 (char *) "type",(char *) "active",(char *) "Id", NULL
24091 };
24092
24093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24094 if (obj0) {
24095 ecode1 = SWIG_AsVal_int(obj0, &val1);
24096 if (!SWIG_IsOK(ecode1)) {
24097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24098 }
24099 arg1 = static_cast< wxEventType >(val1);
24100 }
24101 if (obj1) {
24102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24103 if (!SWIG_IsOK(ecode2)) {
24104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24105 }
24106 arg2 = static_cast< bool >(val2);
24107 }
24108 if (obj2) {
24109 ecode3 = SWIG_AsVal_int(obj2, &val3);
24110 if (!SWIG_IsOK(ecode3)) {
24111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24112 }
24113 arg3 = static_cast< int >(val3);
24114 }
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24129 PyObject *resultobj = 0;
24130 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24131 bool result;
24132 void *argp1 = 0 ;
24133 int res1 = 0 ;
24134 PyObject *swig_obj[1] ;
24135
24136 if (!args) SWIG_fail;
24137 swig_obj[0] = args;
24138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24139 if (!SWIG_IsOK(res1)) {
24140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24141 }
24142 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 {
24150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24151 }
24152 return resultobj;
24153 fail:
24154 return NULL;
24155 }
24156
24157
24158 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24159 PyObject *obj;
24160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24161 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24162 return SWIG_Py_Void();
24163 }
24164
24165 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24166 return SWIG_Python_InitShadowInstance(args);
24167 }
24168
24169 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24170 PyObject *resultobj = 0;
24171 int arg1 = (int) 0 ;
24172 wxInitDialogEvent *result = 0 ;
24173 int val1 ;
24174 int ecode1 = 0 ;
24175 PyObject * obj0 = 0 ;
24176 char * kwnames[] = {
24177 (char *) "Id", NULL
24178 };
24179
24180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24181 if (obj0) {
24182 ecode1 = SWIG_AsVal_int(obj0, &val1);
24183 if (!SWIG_IsOK(ecode1)) {
24184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24185 }
24186 arg1 = static_cast< int >(val1);
24187 }
24188 {
24189 PyThreadState* __tstate = wxPyBeginAllowThreads();
24190 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24191 wxPyEndAllowThreads(__tstate);
24192 if (PyErr_Occurred()) SWIG_fail;
24193 }
24194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24202 PyObject *obj;
24203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24204 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24205 return SWIG_Py_Void();
24206 }
24207
24208 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24209 return SWIG_Python_InitShadowInstance(args);
24210 }
24211
24212 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj = 0;
24214 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24215 int arg2 = (int) 0 ;
24216 wxMenu *arg3 = (wxMenu *) NULL ;
24217 wxMenuEvent *result = 0 ;
24218 int val1 ;
24219 int ecode1 = 0 ;
24220 int val2 ;
24221 int ecode2 = 0 ;
24222 void *argp3 = 0 ;
24223 int res3 = 0 ;
24224 PyObject * obj0 = 0 ;
24225 PyObject * obj1 = 0 ;
24226 PyObject * obj2 = 0 ;
24227 char * kwnames[] = {
24228 (char *) "type",(char *) "winid",(char *) "menu", NULL
24229 };
24230
24231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24232 if (obj0) {
24233 ecode1 = SWIG_AsVal_int(obj0, &val1);
24234 if (!SWIG_IsOK(ecode1)) {
24235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24236 }
24237 arg1 = static_cast< wxEventType >(val1);
24238 }
24239 if (obj1) {
24240 ecode2 = SWIG_AsVal_int(obj1, &val2);
24241 if (!SWIG_IsOK(ecode2)) {
24242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24243 }
24244 arg2 = static_cast< int >(val2);
24245 }
24246 if (obj2) {
24247 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24248 if (!SWIG_IsOK(res3)) {
24249 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24250 }
24251 arg3 = reinterpret_cast< wxMenu * >(argp3);
24252 }
24253 {
24254 PyThreadState* __tstate = wxPyBeginAllowThreads();
24255 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24256 wxPyEndAllowThreads(__tstate);
24257 if (PyErr_Occurred()) SWIG_fail;
24258 }
24259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24260 return resultobj;
24261 fail:
24262 return NULL;
24263 }
24264
24265
24266 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24267 PyObject *resultobj = 0;
24268 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24269 int result;
24270 void *argp1 = 0 ;
24271 int res1 = 0 ;
24272 PyObject *swig_obj[1] ;
24273
24274 if (!args) SWIG_fail;
24275 swig_obj[0] = args;
24276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24277 if (!SWIG_IsOK(res1)) {
24278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24279 }
24280 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 resultobj = SWIG_From_int(static_cast< int >(result));
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24297 bool result;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24307 }
24308 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *resultobj = 0;
24326 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24327 wxMenu *result = 0 ;
24328 void *argp1 = 0 ;
24329 int res1 = 0 ;
24330 PyObject *swig_obj[1] ;
24331
24332 if (!args) SWIG_fail;
24333 swig_obj[0] = args;
24334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24335 if (!SWIG_IsOK(res1)) {
24336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24337 }
24338 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24339 {
24340 PyThreadState* __tstate = wxPyBeginAllowThreads();
24341 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 {
24346 resultobj = wxPyMake_wxObject(result, (bool)0);
24347 }
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355 PyObject *obj;
24356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24357 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24358 return SWIG_Py_Void();
24359 }
24360
24361 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24362 return SWIG_Python_InitShadowInstance(args);
24363 }
24364
24365 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24366 PyObject *resultobj = 0;
24367 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24368 int arg2 = (int) 0 ;
24369 wxCloseEvent *result = 0 ;
24370 int val1 ;
24371 int ecode1 = 0 ;
24372 int val2 ;
24373 int ecode2 = 0 ;
24374 PyObject * obj0 = 0 ;
24375 PyObject * obj1 = 0 ;
24376 char * kwnames[] = {
24377 (char *) "type",(char *) "winid", NULL
24378 };
24379
24380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24381 if (obj0) {
24382 ecode1 = SWIG_AsVal_int(obj0, &val1);
24383 if (!SWIG_IsOK(ecode1)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24385 }
24386 arg1 = static_cast< wxEventType >(val1);
24387 }
24388 if (obj1) {
24389 ecode2 = SWIG_AsVal_int(obj1, &val2);
24390 if (!SWIG_IsOK(ecode2)) {
24391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24392 }
24393 arg2 = static_cast< int >(val2);
24394 }
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj = 0;
24410 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24411 bool arg2 ;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 bool val2 ;
24415 int ecode2 = 0 ;
24416 PyObject * obj0 = 0 ;
24417 PyObject * obj1 = 0 ;
24418 char * kwnames[] = {
24419 (char *) "self",(char *) "logOff", NULL
24420 };
24421
24422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24424 if (!SWIG_IsOK(res1)) {
24425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24426 }
24427 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24429 if (!SWIG_IsOK(ecode2)) {
24430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24431 }
24432 arg2 = static_cast< bool >(val2);
24433 {
24434 PyThreadState* __tstate = wxPyBeginAllowThreads();
24435 (arg1)->SetLoggingOff(arg2);
24436 wxPyEndAllowThreads(__tstate);
24437 if (PyErr_Occurred()) SWIG_fail;
24438 }
24439 resultobj = SWIG_Py_Void();
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447 PyObject *resultobj = 0;
24448 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24449 bool result;
24450 void *argp1 = 0 ;
24451 int res1 = 0 ;
24452 PyObject *swig_obj[1] ;
24453
24454 if (!args) SWIG_fail;
24455 swig_obj[0] = args;
24456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24457 if (!SWIG_IsOK(res1)) {
24458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24459 }
24460 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24464 wxPyEndAllowThreads(__tstate);
24465 if (PyErr_Occurred()) SWIG_fail;
24466 }
24467 {
24468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24469 }
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj = 0;
24478 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24479 bool arg2 = (bool) true ;
24480 void *argp1 = 0 ;
24481 int res1 = 0 ;
24482 bool val2 ;
24483 int ecode2 = 0 ;
24484 PyObject * obj0 = 0 ;
24485 PyObject * obj1 = 0 ;
24486 char * kwnames[] = {
24487 (char *) "self",(char *) "veto", NULL
24488 };
24489
24490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24492 if (!SWIG_IsOK(res1)) {
24493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24494 }
24495 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24496 if (obj1) {
24497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24498 if (!SWIG_IsOK(ecode2)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24500 }
24501 arg2 = static_cast< bool >(val2);
24502 }
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 (arg1)->Veto(arg2);
24506 wxPyEndAllowThreads(__tstate);
24507 if (PyErr_Occurred()) SWIG_fail;
24508 }
24509 resultobj = SWIG_Py_Void();
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24517 PyObject *resultobj = 0;
24518 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24519 bool result;
24520 void *argp1 = 0 ;
24521 int res1 = 0 ;
24522 PyObject *swig_obj[1] ;
24523
24524 if (!args) SWIG_fail;
24525 swig_obj[0] = args;
24526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24527 if (!SWIG_IsOK(res1)) {
24528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24529 }
24530 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 {
24538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24539 }
24540 return resultobj;
24541 fail:
24542 return NULL;
24543 }
24544
24545
24546 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24547 PyObject *resultobj = 0;
24548 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24549 bool arg2 ;
24550 void *argp1 = 0 ;
24551 int res1 = 0 ;
24552 bool val2 ;
24553 int ecode2 = 0 ;
24554 PyObject * obj0 = 0 ;
24555 PyObject * obj1 = 0 ;
24556 char * kwnames[] = {
24557 (char *) "self",(char *) "canVeto", NULL
24558 };
24559
24560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24562 if (!SWIG_IsOK(res1)) {
24563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24564 }
24565 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24567 if (!SWIG_IsOK(ecode2)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24569 }
24570 arg2 = static_cast< bool >(val2);
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 (arg1)->SetCanVeto(arg2);
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 resultobj = SWIG_Py_Void();
24578 return resultobj;
24579 fail:
24580 return NULL;
24581 }
24582
24583
24584 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24585 PyObject *resultobj = 0;
24586 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24587 bool result;
24588 void *argp1 = 0 ;
24589 int res1 = 0 ;
24590 PyObject *swig_obj[1] ;
24591
24592 if (!args) SWIG_fail;
24593 swig_obj[0] = args;
24594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24595 if (!SWIG_IsOK(res1)) {
24596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24597 }
24598 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 {
24606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24607 }
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24615 PyObject *obj;
24616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24617 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24618 return SWIG_Py_Void();
24619 }
24620
24621 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622 return SWIG_Python_InitShadowInstance(args);
24623 }
24624
24625 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24626 PyObject *resultobj = 0;
24627 int arg1 = (int) 0 ;
24628 bool arg2 = (bool) false ;
24629 wxShowEvent *result = 0 ;
24630 int val1 ;
24631 int ecode1 = 0 ;
24632 bool val2 ;
24633 int ecode2 = 0 ;
24634 PyObject * obj0 = 0 ;
24635 PyObject * obj1 = 0 ;
24636 char * kwnames[] = {
24637 (char *) "winid",(char *) "show", NULL
24638 };
24639
24640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24641 if (obj0) {
24642 ecode1 = SWIG_AsVal_int(obj0, &val1);
24643 if (!SWIG_IsOK(ecode1)) {
24644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24645 }
24646 arg1 = static_cast< int >(val1);
24647 }
24648 if (obj1) {
24649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24650 if (!SWIG_IsOK(ecode2)) {
24651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24652 }
24653 arg2 = static_cast< bool >(val2);
24654 }
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = 0;
24670 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24671 bool arg2 ;
24672 void *argp1 = 0 ;
24673 int res1 = 0 ;
24674 bool val2 ;
24675 int ecode2 = 0 ;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 char * kwnames[] = {
24679 (char *) "self",(char *) "show", NULL
24680 };
24681
24682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24684 if (!SWIG_IsOK(res1)) {
24685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24686 }
24687 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24689 if (!SWIG_IsOK(ecode2)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24691 }
24692 arg2 = static_cast< bool >(val2);
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 (arg1)->SetShow(arg2);
24696 wxPyEndAllowThreads(__tstate);
24697 if (PyErr_Occurred()) SWIG_fail;
24698 }
24699 resultobj = SWIG_Py_Void();
24700 return resultobj;
24701 fail:
24702 return NULL;
24703 }
24704
24705
24706 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24707 PyObject *resultobj = 0;
24708 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24709 bool result;
24710 void *argp1 = 0 ;
24711 int res1 = 0 ;
24712 PyObject *swig_obj[1] ;
24713
24714 if (!args) SWIG_fail;
24715 swig_obj[0] = args;
24716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24717 if (!SWIG_IsOK(res1)) {
24718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24719 }
24720 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24721 {
24722 PyThreadState* __tstate = wxPyBeginAllowThreads();
24723 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24724 wxPyEndAllowThreads(__tstate);
24725 if (PyErr_Occurred()) SWIG_fail;
24726 }
24727 {
24728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24729 }
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24737 PyObject *obj;
24738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24739 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24740 return SWIG_Py_Void();
24741 }
24742
24743 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24744 return SWIG_Python_InitShadowInstance(args);
24745 }
24746
24747 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj = 0;
24749 int arg1 = (int) 0 ;
24750 bool arg2 = (bool) true ;
24751 wxIconizeEvent *result = 0 ;
24752 int val1 ;
24753 int ecode1 = 0 ;
24754 bool val2 ;
24755 int ecode2 = 0 ;
24756 PyObject * obj0 = 0 ;
24757 PyObject * obj1 = 0 ;
24758 char * kwnames[] = {
24759 (char *) "id",(char *) "iconized", NULL
24760 };
24761
24762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24763 if (obj0) {
24764 ecode1 = SWIG_AsVal_int(obj0, &val1);
24765 if (!SWIG_IsOK(ecode1)) {
24766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24767 }
24768 arg1 = static_cast< int >(val1);
24769 }
24770 if (obj1) {
24771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24772 if (!SWIG_IsOK(ecode2)) {
24773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24774 }
24775 arg2 = static_cast< bool >(val2);
24776 }
24777 {
24778 PyThreadState* __tstate = wxPyBeginAllowThreads();
24779 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24780 wxPyEndAllowThreads(__tstate);
24781 if (PyErr_Occurred()) SWIG_fail;
24782 }
24783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24791 PyObject *resultobj = 0;
24792 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24793 bool result;
24794 void *argp1 = 0 ;
24795 int res1 = 0 ;
24796 PyObject *swig_obj[1] ;
24797
24798 if (!args) SWIG_fail;
24799 swig_obj[0] = args;
24800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24801 if (!SWIG_IsOK(res1)) {
24802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24803 }
24804 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24805 {
24806 PyThreadState* __tstate = wxPyBeginAllowThreads();
24807 result = (bool)(arg1)->Iconized();
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 {
24812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24813 }
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 PyObject *obj;
24822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24823 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24824 return SWIG_Py_Void();
24825 }
24826
24827 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24828 return SWIG_Python_InitShadowInstance(args);
24829 }
24830
24831 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24832 PyObject *resultobj = 0;
24833 int arg1 = (int) 0 ;
24834 wxMaximizeEvent *result = 0 ;
24835 int val1 ;
24836 int ecode1 = 0 ;
24837 PyObject * obj0 = 0 ;
24838 char * kwnames[] = {
24839 (char *) "id", NULL
24840 };
24841
24842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24843 if (obj0) {
24844 ecode1 = SWIG_AsVal_int(obj0, &val1);
24845 if (!SWIG_IsOK(ecode1)) {
24846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24847 }
24848 arg1 = static_cast< int >(val1);
24849 }
24850 {
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24864 PyObject *obj;
24865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24866 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24867 return SWIG_Py_Void();
24868 }
24869
24870 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24871 return SWIG_Python_InitShadowInstance(args);
24872 }
24873
24874 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24875 PyObject *resultobj = 0;
24876 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24877 wxPoint result;
24878 void *argp1 = 0 ;
24879 int res1 = 0 ;
24880 PyObject *swig_obj[1] ;
24881
24882 if (!args) SWIG_fail;
24883 swig_obj[0] = args;
24884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24885 if (!SWIG_IsOK(res1)) {
24886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24887 }
24888 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (arg1)->GetPosition();
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24903 PyObject *resultobj = 0;
24904 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24905 int result;
24906 void *argp1 = 0 ;
24907 int res1 = 0 ;
24908 PyObject *swig_obj[1] ;
24909
24910 if (!args) SWIG_fail;
24911 swig_obj[0] = args;
24912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24913 if (!SWIG_IsOK(res1)) {
24914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24915 }
24916 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 result = (int)(arg1)->GetNumberOfFiles();
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 resultobj = SWIG_From_int(static_cast< int >(result));
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24931 PyObject *resultobj = 0;
24932 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24933 PyObject *result = 0 ;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 PyObject *swig_obj[1] ;
24937
24938 if (!args) SWIG_fail;
24939 swig_obj[0] = args;
24940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24941 if (!SWIG_IsOK(res1)) {
24942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24943 }
24944 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24945 {
24946 PyThreadState* __tstate = wxPyBeginAllowThreads();
24947 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24948 wxPyEndAllowThreads(__tstate);
24949 if (PyErr_Occurred()) SWIG_fail;
24950 }
24951 resultobj = result;
24952 return resultobj;
24953 fail:
24954 return NULL;
24955 }
24956
24957
24958 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24959 PyObject *obj;
24960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24961 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24962 return SWIG_Py_Void();
24963 }
24964
24965 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24966 PyObject *resultobj = 0;
24967 int arg1 = (int) 0 ;
24968 wxUpdateUIEvent *result = 0 ;
24969 int val1 ;
24970 int ecode1 = 0 ;
24971 PyObject * obj0 = 0 ;
24972 char * kwnames[] = {
24973 (char *) "commandId", NULL
24974 };
24975
24976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24977 if (obj0) {
24978 ecode1 = SWIG_AsVal_int(obj0, &val1);
24979 if (!SWIG_IsOK(ecode1)) {
24980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24981 }
24982 arg1 = static_cast< int >(val1);
24983 }
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24998 PyObject *resultobj = 0;
24999 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25000 bool result;
25001 void *argp1 = 0 ;
25002 int res1 = 0 ;
25003 PyObject *swig_obj[1] ;
25004
25005 if (!args) SWIG_fail;
25006 swig_obj[0] = args;
25007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25008 if (!SWIG_IsOK(res1)) {
25009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25010 }
25011 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25012 {
25013 PyThreadState* __tstate = wxPyBeginAllowThreads();
25014 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25015 wxPyEndAllowThreads(__tstate);
25016 if (PyErr_Occurred()) SWIG_fail;
25017 }
25018 {
25019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25020 }
25021 return resultobj;
25022 fail:
25023 return NULL;
25024 }
25025
25026
25027 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25028 PyObject *resultobj = 0;
25029 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25030 bool result;
25031 void *argp1 = 0 ;
25032 int res1 = 0 ;
25033 PyObject *swig_obj[1] ;
25034
25035 if (!args) SWIG_fail;
25036 swig_obj[0] = args;
25037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25040 }
25041 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 {
25049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25050 }
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25058 PyObject *resultobj = 0;
25059 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25060 bool result;
25061 void *argp1 = 0 ;
25062 int res1 = 0 ;
25063 PyObject *swig_obj[1] ;
25064
25065 if (!args) SWIG_fail;
25066 swig_obj[0] = args;
25067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25068 if (!SWIG_IsOK(res1)) {
25069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25070 }
25071 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25072 {
25073 PyThreadState* __tstate = wxPyBeginAllowThreads();
25074 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25075 wxPyEndAllowThreads(__tstate);
25076 if (PyErr_Occurred()) SWIG_fail;
25077 }
25078 {
25079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25080 }
25081 return resultobj;
25082 fail:
25083 return NULL;
25084 }
25085
25086
25087 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25088 PyObject *resultobj = 0;
25089 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25090 wxString result;
25091 void *argp1 = 0 ;
25092 int res1 = 0 ;
25093 PyObject *swig_obj[1] ;
25094
25095 if (!args) SWIG_fail;
25096 swig_obj[0] = args;
25097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25098 if (!SWIG_IsOK(res1)) {
25099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25100 }
25101 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 {
25109 #if wxUSE_UNICODE
25110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25111 #else
25112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25113 #endif
25114 }
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25122 PyObject *resultobj = 0;
25123 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25124 bool result;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 PyObject *swig_obj[1] ;
25128
25129 if (!args) SWIG_fail;
25130 swig_obj[0] = args;
25131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25132 if (!SWIG_IsOK(res1)) {
25133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25134 }
25135 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 {
25143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25144 }
25145 return resultobj;
25146 fail:
25147 return NULL;
25148 }
25149
25150
25151 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25152 PyObject *resultobj = 0;
25153 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25154 bool result;
25155 void *argp1 = 0 ;
25156 int res1 = 0 ;
25157 PyObject *swig_obj[1] ;
25158
25159 if (!args) SWIG_fail;
25160 swig_obj[0] = args;
25161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25162 if (!SWIG_IsOK(res1)) {
25163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25164 }
25165 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25166 {
25167 PyThreadState* __tstate = wxPyBeginAllowThreads();
25168 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25169 wxPyEndAllowThreads(__tstate);
25170 if (PyErr_Occurred()) SWIG_fail;
25171 }
25172 {
25173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25174 }
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25182 PyObject *resultobj = 0;
25183 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25184 bool result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 PyObject *swig_obj[1] ;
25188
25189 if (!args) SWIG_fail;
25190 swig_obj[0] = args;
25191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25192 if (!SWIG_IsOK(res1)) {
25193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25194 }
25195 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25199 wxPyEndAllowThreads(__tstate);
25200 if (PyErr_Occurred()) SWIG_fail;
25201 }
25202 {
25203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25204 }
25205 return resultobj;
25206 fail:
25207 return NULL;
25208 }
25209
25210
25211 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25212 PyObject *resultobj = 0;
25213 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25214 bool result;
25215 void *argp1 = 0 ;
25216 int res1 = 0 ;
25217 PyObject *swig_obj[1] ;
25218
25219 if (!args) SWIG_fail;
25220 swig_obj[0] = args;
25221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25222 if (!SWIG_IsOK(res1)) {
25223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25224 }
25225 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 {
25233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25234 }
25235 return resultobj;
25236 fail:
25237 return NULL;
25238 }
25239
25240
25241 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25242 PyObject *resultobj = 0;
25243 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25244 bool arg2 ;
25245 void *argp1 = 0 ;
25246 int res1 = 0 ;
25247 bool val2 ;
25248 int ecode2 = 0 ;
25249 PyObject * obj0 = 0 ;
25250 PyObject * obj1 = 0 ;
25251 char * kwnames[] = {
25252 (char *) "self",(char *) "check", NULL
25253 };
25254
25255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25257 if (!SWIG_IsOK(res1)) {
25258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25259 }
25260 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25262 if (!SWIG_IsOK(ecode2)) {
25263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25264 }
25265 arg2 = static_cast< bool >(val2);
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 (arg1)->Check(arg2);
25269 wxPyEndAllowThreads(__tstate);
25270 if (PyErr_Occurred()) SWIG_fail;
25271 }
25272 resultobj = SWIG_Py_Void();
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25280 PyObject *resultobj = 0;
25281 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25282 bool arg2 ;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 bool val2 ;
25286 int ecode2 = 0 ;
25287 PyObject * obj0 = 0 ;
25288 PyObject * obj1 = 0 ;
25289 char * kwnames[] = {
25290 (char *) "self",(char *) "enable", NULL
25291 };
25292
25293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25295 if (!SWIG_IsOK(res1)) {
25296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25297 }
25298 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25299 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25300 if (!SWIG_IsOK(ecode2)) {
25301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25302 }
25303 arg2 = static_cast< bool >(val2);
25304 {
25305 PyThreadState* __tstate = wxPyBeginAllowThreads();
25306 (arg1)->Enable(arg2);
25307 wxPyEndAllowThreads(__tstate);
25308 if (PyErr_Occurred()) SWIG_fail;
25309 }
25310 resultobj = SWIG_Py_Void();
25311 return resultobj;
25312 fail:
25313 return NULL;
25314 }
25315
25316
25317 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25318 PyObject *resultobj = 0;
25319 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25320 bool arg2 ;
25321 void *argp1 = 0 ;
25322 int res1 = 0 ;
25323 bool val2 ;
25324 int ecode2 = 0 ;
25325 PyObject * obj0 = 0 ;
25326 PyObject * obj1 = 0 ;
25327 char * kwnames[] = {
25328 (char *) "self",(char *) "show", NULL
25329 };
25330
25331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25335 }
25336 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25337 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25338 if (!SWIG_IsOK(ecode2)) {
25339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25340 }
25341 arg2 = static_cast< bool >(val2);
25342 {
25343 PyThreadState* __tstate = wxPyBeginAllowThreads();
25344 (arg1)->Show(arg2);
25345 wxPyEndAllowThreads(__tstate);
25346 if (PyErr_Occurred()) SWIG_fail;
25347 }
25348 resultobj = SWIG_Py_Void();
25349 return resultobj;
25350 fail:
25351 return NULL;
25352 }
25353
25354
25355 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25356 PyObject *resultobj = 0;
25357 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25358 wxString *arg2 = 0 ;
25359 void *argp1 = 0 ;
25360 int res1 = 0 ;
25361 bool temp2 = false ;
25362 PyObject * obj0 = 0 ;
25363 PyObject * obj1 = 0 ;
25364 char * kwnames[] = {
25365 (char *) "self",(char *) "text", NULL
25366 };
25367
25368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25370 if (!SWIG_IsOK(res1)) {
25371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25372 }
25373 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25374 {
25375 arg2 = wxString_in_helper(obj1);
25376 if (arg2 == NULL) SWIG_fail;
25377 temp2 = true;
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 (arg1)->SetText((wxString const &)*arg2);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_Py_Void();
25386 {
25387 if (temp2)
25388 delete arg2;
25389 }
25390 return resultobj;
25391 fail:
25392 {
25393 if (temp2)
25394 delete arg2;
25395 }
25396 return NULL;
25397 }
25398
25399
25400 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj = 0;
25402 long arg1 ;
25403 long val1 ;
25404 int ecode1 = 0 ;
25405 PyObject * obj0 = 0 ;
25406 char * kwnames[] = {
25407 (char *) "updateInterval", NULL
25408 };
25409
25410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25411 ecode1 = SWIG_AsVal_long(obj0, &val1);
25412 if (!SWIG_IsOK(ecode1)) {
25413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25414 }
25415 arg1 = static_cast< long >(val1);
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 wxUpdateUIEvent::SetUpdateInterval(arg1);
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = SWIG_Py_Void();
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *resultobj = 0;
25431 long result;
25432
25433 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25434 {
25435 PyThreadState* __tstate = wxPyBeginAllowThreads();
25436 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25437 wxPyEndAllowThreads(__tstate);
25438 if (PyErr_Occurred()) SWIG_fail;
25439 }
25440 resultobj = SWIG_From_long(static_cast< long >(result));
25441 return resultobj;
25442 fail:
25443 return NULL;
25444 }
25445
25446
25447 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25448 PyObject *resultobj = 0;
25449 wxWindow *arg1 = (wxWindow *) 0 ;
25450 bool result;
25451 void *argp1 = 0 ;
25452 int res1 = 0 ;
25453 PyObject * obj0 = 0 ;
25454 char * kwnames[] = {
25455 (char *) "win", NULL
25456 };
25457
25458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25460 if (!SWIG_IsOK(res1)) {
25461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25462 }
25463 arg1 = reinterpret_cast< wxWindow * >(argp1);
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 {
25471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25472 }
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25480 PyObject *resultobj = 0;
25481
25482 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25483 {
25484 PyThreadState* __tstate = wxPyBeginAllowThreads();
25485 wxUpdateUIEvent::ResetUpdateTime();
25486 wxPyEndAllowThreads(__tstate);
25487 if (PyErr_Occurred()) SWIG_fail;
25488 }
25489 resultobj = SWIG_Py_Void();
25490 return resultobj;
25491 fail:
25492 return NULL;
25493 }
25494
25495
25496 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25497 PyObject *resultobj = 0;
25498 wxUpdateUIMode arg1 ;
25499 int val1 ;
25500 int ecode1 = 0 ;
25501 PyObject * obj0 = 0 ;
25502 char * kwnames[] = {
25503 (char *) "mode", NULL
25504 };
25505
25506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25507 ecode1 = SWIG_AsVal_int(obj0, &val1);
25508 if (!SWIG_IsOK(ecode1)) {
25509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25510 }
25511 arg1 = static_cast< wxUpdateUIMode >(val1);
25512 {
25513 PyThreadState* __tstate = wxPyBeginAllowThreads();
25514 wxUpdateUIEvent::SetMode(arg1);
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 resultobj = SWIG_Py_Void();
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 PyObject *resultobj = 0;
25527 wxUpdateUIMode result;
25528
25529 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25530 {
25531 PyThreadState* __tstate = wxPyBeginAllowThreads();
25532 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 resultobj = SWIG_From_int(static_cast< int >(result));
25537 return resultobj;
25538 fail:
25539 return NULL;
25540 }
25541
25542
25543 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25544 PyObject *obj;
25545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25546 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25547 return SWIG_Py_Void();
25548 }
25549
25550 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25551 return SWIG_Python_InitShadowInstance(args);
25552 }
25553
25554 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 PyObject *resultobj = 0;
25556 wxSysColourChangedEvent *result = 0 ;
25557
25558 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25559 {
25560 PyThreadState* __tstate = wxPyBeginAllowThreads();
25561 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25573 PyObject *obj;
25574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25575 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25576 return SWIG_Py_Void();
25577 }
25578
25579 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 return SWIG_Python_InitShadowInstance(args);
25581 }
25582
25583 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25584 PyObject *resultobj = 0;
25585 int arg1 = (int) 0 ;
25586 wxWindow *arg2 = (wxWindow *) NULL ;
25587 wxMouseCaptureChangedEvent *result = 0 ;
25588 int val1 ;
25589 int ecode1 = 0 ;
25590 void *argp2 = 0 ;
25591 int res2 = 0 ;
25592 PyObject * obj0 = 0 ;
25593 PyObject * obj1 = 0 ;
25594 char * kwnames[] = {
25595 (char *) "winid",(char *) "gainedCapture", NULL
25596 };
25597
25598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25599 if (obj0) {
25600 ecode1 = SWIG_AsVal_int(obj0, &val1);
25601 if (!SWIG_IsOK(ecode1)) {
25602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25603 }
25604 arg1 = static_cast< int >(val1);
25605 }
25606 if (obj1) {
25607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25608 if (!SWIG_IsOK(res2)) {
25609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25610 }
25611 arg2 = reinterpret_cast< wxWindow * >(argp2);
25612 }
25613 {
25614 PyThreadState* __tstate = wxPyBeginAllowThreads();
25615 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25616 wxPyEndAllowThreads(__tstate);
25617 if (PyErr_Occurred()) SWIG_fail;
25618 }
25619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25620 return resultobj;
25621 fail:
25622 return NULL;
25623 }
25624
25625
25626 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25627 PyObject *resultobj = 0;
25628 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25629 wxWindow *result = 0 ;
25630 void *argp1 = 0 ;
25631 int res1 = 0 ;
25632 PyObject *swig_obj[1] ;
25633
25634 if (!args) SWIG_fail;
25635 swig_obj[0] = args;
25636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25637 if (!SWIG_IsOK(res1)) {
25638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25639 }
25640 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 {
25648 resultobj = wxPyMake_wxObject(result, (bool)0);
25649 }
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 PyObject *obj;
25658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25659 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25660 return SWIG_Py_Void();
25661 }
25662
25663 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25664 return SWIG_Python_InitShadowInstance(args);
25665 }
25666
25667 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj = 0;
25669 int arg1 = (int) 0 ;
25670 wxMouseCaptureLostEvent *result = 0 ;
25671 int val1 ;
25672 int ecode1 = 0 ;
25673 PyObject * obj0 = 0 ;
25674 char * kwnames[] = {
25675 (char *) "winid", NULL
25676 };
25677
25678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25679 if (obj0) {
25680 ecode1 = SWIG_AsVal_int(obj0, &val1);
25681 if (!SWIG_IsOK(ecode1)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25683 }
25684 arg1 = static_cast< int >(val1);
25685 }
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25689 wxPyEndAllowThreads(__tstate);
25690 if (PyErr_Occurred()) SWIG_fail;
25691 }
25692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25693 return resultobj;
25694 fail:
25695 return NULL;
25696 }
25697
25698
25699 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25700 PyObject *obj;
25701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25702 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25703 return SWIG_Py_Void();
25704 }
25705
25706 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25707 return SWIG_Python_InitShadowInstance(args);
25708 }
25709
25710 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25711 PyObject *resultobj = 0;
25712 wxDisplayChangedEvent *result = 0 ;
25713
25714 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25715 {
25716 PyThreadState* __tstate = wxPyBeginAllowThreads();
25717 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25718 wxPyEndAllowThreads(__tstate);
25719 if (PyErr_Occurred()) SWIG_fail;
25720 }
25721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25729 PyObject *obj;
25730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25731 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25732 return SWIG_Py_Void();
25733 }
25734
25735 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25736 return SWIG_Python_InitShadowInstance(args);
25737 }
25738
25739 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj = 0;
25741 int arg1 = (int) 0 ;
25742 wxPaletteChangedEvent *result = 0 ;
25743 int val1 ;
25744 int ecode1 = 0 ;
25745 PyObject * obj0 = 0 ;
25746 char * kwnames[] = {
25747 (char *) "id", NULL
25748 };
25749
25750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25751 if (obj0) {
25752 ecode1 = SWIG_AsVal_int(obj0, &val1);
25753 if (!SWIG_IsOK(ecode1)) {
25754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25755 }
25756 arg1 = static_cast< int >(val1);
25757 }
25758 {
25759 PyThreadState* __tstate = wxPyBeginAllowThreads();
25760 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25761 wxPyEndAllowThreads(__tstate);
25762 if (PyErr_Occurred()) SWIG_fail;
25763 }
25764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25772 PyObject *resultobj = 0;
25773 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25774 wxWindow *arg2 = (wxWindow *) 0 ;
25775 void *argp1 = 0 ;
25776 int res1 = 0 ;
25777 void *argp2 = 0 ;
25778 int res2 = 0 ;
25779 PyObject * obj0 = 0 ;
25780 PyObject * obj1 = 0 ;
25781 char * kwnames[] = {
25782 (char *) "self",(char *) "win", NULL
25783 };
25784
25785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25787 if (!SWIG_IsOK(res1)) {
25788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25789 }
25790 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25792 if (!SWIG_IsOK(res2)) {
25793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25794 }
25795 arg2 = reinterpret_cast< wxWindow * >(argp2);
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 (arg1)->SetChangedWindow(arg2);
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 resultobj = SWIG_Py_Void();
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25810 PyObject *resultobj = 0;
25811 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25812 wxWindow *result = 0 ;
25813 void *argp1 = 0 ;
25814 int res1 = 0 ;
25815 PyObject *swig_obj[1] ;
25816
25817 if (!args) SWIG_fail;
25818 swig_obj[0] = args;
25819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25820 if (!SWIG_IsOK(res1)) {
25821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25822 }
25823 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25824 {
25825 PyThreadState* __tstate = wxPyBeginAllowThreads();
25826 result = (wxWindow *)(arg1)->GetChangedWindow();
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 {
25831 resultobj = wxPyMake_wxObject(result, (bool)0);
25832 }
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25840 PyObject *obj;
25841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25842 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25843 return SWIG_Py_Void();
25844 }
25845
25846 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25847 return SWIG_Python_InitShadowInstance(args);
25848 }
25849
25850 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25851 PyObject *resultobj = 0;
25852 int arg1 = (int) 0 ;
25853 wxQueryNewPaletteEvent *result = 0 ;
25854 int val1 ;
25855 int ecode1 = 0 ;
25856 PyObject * obj0 = 0 ;
25857 char * kwnames[] = {
25858 (char *) "winid", NULL
25859 };
25860
25861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25862 if (obj0) {
25863 ecode1 = SWIG_AsVal_int(obj0, &val1);
25864 if (!SWIG_IsOK(ecode1)) {
25865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25866 }
25867 arg1 = static_cast< int >(val1);
25868 }
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25876 return resultobj;
25877 fail:
25878 return NULL;
25879 }
25880
25881
25882 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25883 PyObject *resultobj = 0;
25884 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25885 bool arg2 ;
25886 void *argp1 = 0 ;
25887 int res1 = 0 ;
25888 bool val2 ;
25889 int ecode2 = 0 ;
25890 PyObject * obj0 = 0 ;
25891 PyObject * obj1 = 0 ;
25892 char * kwnames[] = {
25893 (char *) "self",(char *) "realized", NULL
25894 };
25895
25896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25898 if (!SWIG_IsOK(res1)) {
25899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25900 }
25901 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25902 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25903 if (!SWIG_IsOK(ecode2)) {
25904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25905 }
25906 arg2 = static_cast< bool >(val2);
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 (arg1)->SetPaletteRealized(arg2);
25910 wxPyEndAllowThreads(__tstate);
25911 if (PyErr_Occurred()) SWIG_fail;
25912 }
25913 resultobj = SWIG_Py_Void();
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25921 PyObject *resultobj = 0;
25922 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25923 bool result;
25924 void *argp1 = 0 ;
25925 int res1 = 0 ;
25926 PyObject *swig_obj[1] ;
25927
25928 if (!args) SWIG_fail;
25929 swig_obj[0] = args;
25930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25931 if (!SWIG_IsOK(res1)) {
25932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25933 }
25934 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 {
25942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25943 }
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951 PyObject *obj;
25952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25953 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25954 return SWIG_Py_Void();
25955 }
25956
25957 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 return SWIG_Python_InitShadowInstance(args);
25959 }
25960
25961 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25962 PyObject *resultobj = 0;
25963 wxNavigationKeyEvent *result = 0 ;
25964
25965 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25969 wxPyEndAllowThreads(__tstate);
25970 if (PyErr_Occurred()) SWIG_fail;
25971 }
25972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25973 return resultobj;
25974 fail:
25975 return NULL;
25976 }
25977
25978
25979 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25980 PyObject *resultobj = 0;
25981 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25982 bool result;
25983 void *argp1 = 0 ;
25984 int res1 = 0 ;
25985 PyObject *swig_obj[1] ;
25986
25987 if (!args) SWIG_fail;
25988 swig_obj[0] = args;
25989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25990 if (!SWIG_IsOK(res1)) {
25991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25992 }
25993 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25997 wxPyEndAllowThreads(__tstate);
25998 if (PyErr_Occurred()) SWIG_fail;
25999 }
26000 {
26001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26002 }
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26010 PyObject *resultobj = 0;
26011 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26012 bool arg2 ;
26013 void *argp1 = 0 ;
26014 int res1 = 0 ;
26015 bool val2 ;
26016 int ecode2 = 0 ;
26017 PyObject * obj0 = 0 ;
26018 PyObject * obj1 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "self",(char *) "forward", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26027 }
26028 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26030 if (!SWIG_IsOK(ecode2)) {
26031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26032 }
26033 arg2 = static_cast< bool >(val2);
26034 {
26035 PyThreadState* __tstate = wxPyBeginAllowThreads();
26036 (arg1)->SetDirection(arg2);
26037 wxPyEndAllowThreads(__tstate);
26038 if (PyErr_Occurred()) SWIG_fail;
26039 }
26040 resultobj = SWIG_Py_Void();
26041 return resultobj;
26042 fail:
26043 return NULL;
26044 }
26045
26046
26047 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26048 PyObject *resultobj = 0;
26049 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26050 bool result;
26051 void *argp1 = 0 ;
26052 int res1 = 0 ;
26053 PyObject *swig_obj[1] ;
26054
26055 if (!args) SWIG_fail;
26056 swig_obj[0] = args;
26057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26058 if (!SWIG_IsOK(res1)) {
26059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26060 }
26061 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26062 {
26063 PyThreadState* __tstate = wxPyBeginAllowThreads();
26064 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26065 wxPyEndAllowThreads(__tstate);
26066 if (PyErr_Occurred()) SWIG_fail;
26067 }
26068 {
26069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26070 }
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26078 PyObject *resultobj = 0;
26079 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26080 bool arg2 ;
26081 void *argp1 = 0 ;
26082 int res1 = 0 ;
26083 bool val2 ;
26084 int ecode2 = 0 ;
26085 PyObject * obj0 = 0 ;
26086 PyObject * obj1 = 0 ;
26087 char * kwnames[] = {
26088 (char *) "self",(char *) "ischange", NULL
26089 };
26090
26091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26093 if (!SWIG_IsOK(res1)) {
26094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26095 }
26096 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26098 if (!SWIG_IsOK(ecode2)) {
26099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26100 }
26101 arg2 = static_cast< bool >(val2);
26102 {
26103 PyThreadState* __tstate = wxPyBeginAllowThreads();
26104 (arg1)->SetWindowChange(arg2);
26105 wxPyEndAllowThreads(__tstate);
26106 if (PyErr_Occurred()) SWIG_fail;
26107 }
26108 resultobj = SWIG_Py_Void();
26109 return resultobj;
26110 fail:
26111 return NULL;
26112 }
26113
26114
26115 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26116 PyObject *resultobj = 0;
26117 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26118 bool result;
26119 void *argp1 = 0 ;
26120 int res1 = 0 ;
26121 PyObject *swig_obj[1] ;
26122
26123 if (!args) SWIG_fail;
26124 swig_obj[0] = args;
26125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26126 if (!SWIG_IsOK(res1)) {
26127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26128 }
26129 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26130 {
26131 PyThreadState* __tstate = wxPyBeginAllowThreads();
26132 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26133 wxPyEndAllowThreads(__tstate);
26134 if (PyErr_Occurred()) SWIG_fail;
26135 }
26136 {
26137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26138 }
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj = 0;
26147 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26148 bool arg2 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 bool val2 ;
26152 int ecode2 = 0 ;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 char * kwnames[] = {
26156 (char *) "self",(char *) "bIs", NULL
26157 };
26158
26159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26163 }
26164 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26166 if (!SWIG_IsOK(ecode2)) {
26167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26168 }
26169 arg2 = static_cast< bool >(val2);
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 (arg1)->SetFromTab(arg2);
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 resultobj = SWIG_Py_Void();
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26184 PyObject *resultobj = 0;
26185 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26186 long arg2 ;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 long val2 ;
26190 int ecode2 = 0 ;
26191 PyObject * obj0 = 0 ;
26192 PyObject * obj1 = 0 ;
26193 char * kwnames[] = {
26194 (char *) "self",(char *) "flags", NULL
26195 };
26196
26197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26199 if (!SWIG_IsOK(res1)) {
26200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26201 }
26202 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26203 ecode2 = SWIG_AsVal_long(obj1, &val2);
26204 if (!SWIG_IsOK(ecode2)) {
26205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26206 }
26207 arg2 = static_cast< long >(val2);
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 (arg1)->SetFlags(arg2);
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 resultobj = SWIG_Py_Void();
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *resultobj = 0;
26223 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26224 wxWindow *result = 0 ;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 PyObject *swig_obj[1] ;
26228
26229 if (!args) SWIG_fail;
26230 swig_obj[0] = args;
26231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26234 }
26235 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26236 {
26237 PyThreadState* __tstate = wxPyBeginAllowThreads();
26238 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 {
26243 resultobj = wxPyMake_wxObject(result, (bool)0);
26244 }
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26252 PyObject *resultobj = 0;
26253 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26254 wxWindow *arg2 = (wxWindow *) 0 ;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 void *argp2 = 0 ;
26258 int res2 = 0 ;
26259 PyObject * obj0 = 0 ;
26260 PyObject * obj1 = 0 ;
26261 char * kwnames[] = {
26262 (char *) "self",(char *) "win", NULL
26263 };
26264
26265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26267 if (!SWIG_IsOK(res1)) {
26268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26269 }
26270 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26272 if (!SWIG_IsOK(res2)) {
26273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26274 }
26275 arg2 = reinterpret_cast< wxWindow * >(argp2);
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 (arg1)->SetCurrentFocus(arg2);
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_Py_Void();
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *obj;
26291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26292 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26293 return SWIG_Py_Void();
26294 }
26295
26296 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 return SWIG_Python_InitShadowInstance(args);
26298 }
26299
26300 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26301 PyObject *resultobj = 0;
26302 wxWindow *arg1 = (wxWindow *) NULL ;
26303 wxWindowCreateEvent *result = 0 ;
26304 void *argp1 = 0 ;
26305 int res1 = 0 ;
26306 PyObject * obj0 = 0 ;
26307 char * kwnames[] = {
26308 (char *) "win", NULL
26309 };
26310
26311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26312 if (obj0) {
26313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26314 if (!SWIG_IsOK(res1)) {
26315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26316 }
26317 arg1 = reinterpret_cast< wxWindow * >(argp1);
26318 }
26319 {
26320 PyThreadState* __tstate = wxPyBeginAllowThreads();
26321 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26322 wxPyEndAllowThreads(__tstate);
26323 if (PyErr_Occurred()) SWIG_fail;
26324 }
26325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26326 return resultobj;
26327 fail:
26328 return NULL;
26329 }
26330
26331
26332 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26333 PyObject *resultobj = 0;
26334 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26335 wxWindow *result = 0 ;
26336 void *argp1 = 0 ;
26337 int res1 = 0 ;
26338 PyObject *swig_obj[1] ;
26339
26340 if (!args) SWIG_fail;
26341 swig_obj[0] = args;
26342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26343 if (!SWIG_IsOK(res1)) {
26344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26345 }
26346 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26350 wxPyEndAllowThreads(__tstate);
26351 if (PyErr_Occurred()) SWIG_fail;
26352 }
26353 {
26354 resultobj = wxPyMake_wxObject(result, (bool)0);
26355 }
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *obj;
26364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26365 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26366 return SWIG_Py_Void();
26367 }
26368
26369 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26370 return SWIG_Python_InitShadowInstance(args);
26371 }
26372
26373 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26374 PyObject *resultobj = 0;
26375 wxWindow *arg1 = (wxWindow *) NULL ;
26376 wxWindowDestroyEvent *result = 0 ;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 PyObject * obj0 = 0 ;
26380 char * kwnames[] = {
26381 (char *) "win", NULL
26382 };
26383
26384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26385 if (obj0) {
26386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26387 if (!SWIG_IsOK(res1)) {
26388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26389 }
26390 arg1 = reinterpret_cast< wxWindow * >(argp1);
26391 }
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 PyObject *resultobj = 0;
26407 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26408 wxWindow *result = 0 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 PyObject *swig_obj[1] ;
26412
26413 if (!args) SWIG_fail;
26414 swig_obj[0] = args;
26415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26416 if (!SWIG_IsOK(res1)) {
26417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26418 }
26419 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 {
26427 resultobj = wxPyMake_wxObject(result, (bool)0);
26428 }
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26436 PyObject *obj;
26437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26438 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26439 return SWIG_Py_Void();
26440 }
26441
26442 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26443 return SWIG_Python_InitShadowInstance(args);
26444 }
26445
26446 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26447 PyObject *resultobj = 0;
26448 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26449 int arg2 = (int) 0 ;
26450 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26451 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26452 wxContextMenuEvent *result = 0 ;
26453 int val1 ;
26454 int ecode1 = 0 ;
26455 int val2 ;
26456 int ecode2 = 0 ;
26457 wxPoint temp3 ;
26458 PyObject * obj0 = 0 ;
26459 PyObject * obj1 = 0 ;
26460 PyObject * obj2 = 0 ;
26461 char * kwnames[] = {
26462 (char *) "type",(char *) "winid",(char *) "pt", NULL
26463 };
26464
26465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26466 if (obj0) {
26467 ecode1 = SWIG_AsVal_int(obj0, &val1);
26468 if (!SWIG_IsOK(ecode1)) {
26469 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26470 }
26471 arg1 = static_cast< wxEventType >(val1);
26472 }
26473 if (obj1) {
26474 ecode2 = SWIG_AsVal_int(obj1, &val2);
26475 if (!SWIG_IsOK(ecode2)) {
26476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26477 }
26478 arg2 = static_cast< int >(val2);
26479 }
26480 if (obj2) {
26481 {
26482 arg3 = &temp3;
26483 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26484 }
26485 }
26486 {
26487 PyThreadState* __tstate = wxPyBeginAllowThreads();
26488 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26500 PyObject *resultobj = 0;
26501 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26502 wxPoint *result = 0 ;
26503 void *argp1 = 0 ;
26504 int res1 = 0 ;
26505 PyObject *swig_obj[1] ;
26506
26507 if (!args) SWIG_fail;
26508 swig_obj[0] = args;
26509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26510 if (!SWIG_IsOK(res1)) {
26511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26512 }
26513 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26514 {
26515 PyThreadState* __tstate = wxPyBeginAllowThreads();
26516 {
26517 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26518 result = (wxPoint *) &_result_ref;
26519 }
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj = 0;
26532 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26533 wxPoint *arg2 = 0 ;
26534 void *argp1 = 0 ;
26535 int res1 = 0 ;
26536 wxPoint temp2 ;
26537 PyObject * obj0 = 0 ;
26538 PyObject * obj1 = 0 ;
26539 char * kwnames[] = {
26540 (char *) "self",(char *) "pos", NULL
26541 };
26542
26543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26545 if (!SWIG_IsOK(res1)) {
26546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26547 }
26548 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26549 {
26550 arg2 = &temp2;
26551 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26552 }
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 (arg1)->SetPosition((wxPoint const &)*arg2);
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = SWIG_Py_Void();
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26567 PyObject *obj;
26568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26569 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26570 return SWIG_Py_Void();
26571 }
26572
26573 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26574 return SWIG_Python_InitShadowInstance(args);
26575 }
26576
26577 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26578 PyObject *resultobj = 0;
26579 wxIdleEvent *result = 0 ;
26580
26581 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = (wxIdleEvent *)new wxIdleEvent();
26585 wxPyEndAllowThreads(__tstate);
26586 if (PyErr_Occurred()) SWIG_fail;
26587 }
26588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = 0;
26597 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26598 bool arg2 = (bool) true ;
26599 void *argp1 = 0 ;
26600 int res1 = 0 ;
26601 bool val2 ;
26602 int ecode2 = 0 ;
26603 PyObject * obj0 = 0 ;
26604 PyObject * obj1 = 0 ;
26605 char * kwnames[] = {
26606 (char *) "self",(char *) "needMore", NULL
26607 };
26608
26609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26611 if (!SWIG_IsOK(res1)) {
26612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26613 }
26614 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26615 if (obj1) {
26616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26617 if (!SWIG_IsOK(ecode2)) {
26618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26619 }
26620 arg2 = static_cast< bool >(val2);
26621 }
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 (arg1)->RequestMore(arg2);
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 resultobj = SWIG_Py_Void();
26629 return resultobj;
26630 fail:
26631 return NULL;
26632 }
26633
26634
26635 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26636 PyObject *resultobj = 0;
26637 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26638 bool result;
26639 void *argp1 = 0 ;
26640 int res1 = 0 ;
26641 PyObject *swig_obj[1] ;
26642
26643 if (!args) SWIG_fail;
26644 swig_obj[0] = args;
26645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26646 if (!SWIG_IsOK(res1)) {
26647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26648 }
26649 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26650 {
26651 PyThreadState* __tstate = wxPyBeginAllowThreads();
26652 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 {
26657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26658 }
26659 return resultobj;
26660 fail:
26661 return NULL;
26662 }
26663
26664
26665 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26666 PyObject *resultobj = 0;
26667 wxIdleMode arg1 ;
26668 int val1 ;
26669 int ecode1 = 0 ;
26670 PyObject * obj0 = 0 ;
26671 char * kwnames[] = {
26672 (char *) "mode", NULL
26673 };
26674
26675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26676 ecode1 = SWIG_AsVal_int(obj0, &val1);
26677 if (!SWIG_IsOK(ecode1)) {
26678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26679 }
26680 arg1 = static_cast< wxIdleMode >(val1);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 wxIdleEvent::SetMode(arg1);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 resultobj = SWIG_Py_Void();
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26695 PyObject *resultobj = 0;
26696 wxIdleMode result;
26697
26698 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 result = (wxIdleMode)wxIdleEvent::GetMode();
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_From_int(static_cast< int >(result));
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26713 PyObject *resultobj = 0;
26714 wxWindow *arg1 = (wxWindow *) 0 ;
26715 bool result;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 PyObject * obj0 = 0 ;
26719 char * kwnames[] = {
26720 (char *) "win", NULL
26721 };
26722
26723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26725 if (!SWIG_IsOK(res1)) {
26726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26727 }
26728 arg1 = reinterpret_cast< wxWindow * >(argp1);
26729 {
26730 PyThreadState* __tstate = wxPyBeginAllowThreads();
26731 result = (bool)wxIdleEvent::CanSend(arg1);
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 {
26736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26737 }
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26745 PyObject *obj;
26746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26747 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26748 return SWIG_Py_Void();
26749 }
26750
26751 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26752 return SWIG_Python_InitShadowInstance(args);
26753 }
26754
26755 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = 0;
26757 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26758 int arg2 = (int) 0 ;
26759 wxClipboardTextEvent *result = 0 ;
26760 int val1 ;
26761 int ecode1 = 0 ;
26762 int val2 ;
26763 int ecode2 = 0 ;
26764 PyObject * obj0 = 0 ;
26765 PyObject * obj1 = 0 ;
26766 char * kwnames[] = {
26767 (char *) "type",(char *) "winid", NULL
26768 };
26769
26770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26771 if (obj0) {
26772 ecode1 = SWIG_AsVal_int(obj0, &val1);
26773 if (!SWIG_IsOK(ecode1)) {
26774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26775 }
26776 arg1 = static_cast< wxEventType >(val1);
26777 }
26778 if (obj1) {
26779 ecode2 = SWIG_AsVal_int(obj1, &val2);
26780 if (!SWIG_IsOK(ecode2)) {
26781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26782 }
26783 arg2 = static_cast< int >(val2);
26784 }
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26792 return resultobj;
26793 fail:
26794 return NULL;
26795 }
26796
26797
26798 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26799 PyObject *obj;
26800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26801 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26802 return SWIG_Py_Void();
26803 }
26804
26805 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26806 return SWIG_Python_InitShadowInstance(args);
26807 }
26808
26809 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26810 PyObject *resultobj = 0;
26811 int arg1 = (int) 0 ;
26812 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26813 wxPyEvent *result = 0 ;
26814 int val1 ;
26815 int ecode1 = 0 ;
26816 int val2 ;
26817 int ecode2 = 0 ;
26818 PyObject * obj0 = 0 ;
26819 PyObject * obj1 = 0 ;
26820 char * kwnames[] = {
26821 (char *) "winid",(char *) "eventType", NULL
26822 };
26823
26824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26825 if (obj0) {
26826 ecode1 = SWIG_AsVal_int(obj0, &val1);
26827 if (!SWIG_IsOK(ecode1)) {
26828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26829 }
26830 arg1 = static_cast< int >(val1);
26831 }
26832 if (obj1) {
26833 ecode2 = SWIG_AsVal_int(obj1, &val2);
26834 if (!SWIG_IsOK(ecode2)) {
26835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26836 }
26837 arg2 = static_cast< wxEventType >(val2);
26838 }
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26842 wxPyEndAllowThreads(__tstate);
26843 if (PyErr_Occurred()) SWIG_fail;
26844 }
26845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26853 PyObject *resultobj = 0;
26854 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26855 void *argp1 = 0 ;
26856 int res1 = 0 ;
26857 PyObject *swig_obj[1] ;
26858
26859 if (!args) SWIG_fail;
26860 swig_obj[0] = args;
26861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26862 if (!SWIG_IsOK(res1)) {
26863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26864 }
26865 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26866 {
26867 PyThreadState* __tstate = wxPyBeginAllowThreads();
26868 delete arg1;
26869
26870 wxPyEndAllowThreads(__tstate);
26871 if (PyErr_Occurred()) SWIG_fail;
26872 }
26873 resultobj = SWIG_Py_Void();
26874 return resultobj;
26875 fail:
26876 return NULL;
26877 }
26878
26879
26880 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26881 PyObject *resultobj = 0;
26882 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26883 PyObject *arg2 = (PyObject *) 0 ;
26884 void *argp1 = 0 ;
26885 int res1 = 0 ;
26886 PyObject * obj0 = 0 ;
26887 PyObject * obj1 = 0 ;
26888 char * kwnames[] = {
26889 (char *) "self",(char *) "self", NULL
26890 };
26891
26892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26894 if (!SWIG_IsOK(res1)) {
26895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26896 }
26897 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26898 arg2 = obj1;
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 (arg1)->SetSelf(arg2);
26902 wxPyEndAllowThreads(__tstate);
26903 if (PyErr_Occurred()) SWIG_fail;
26904 }
26905 resultobj = SWIG_Py_Void();
26906 return resultobj;
26907 fail:
26908 return NULL;
26909 }
26910
26911
26912 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26913 PyObject *resultobj = 0;
26914 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26915 PyObject *result = 0 ;
26916 void *argp1 = 0 ;
26917 int res1 = 0 ;
26918 PyObject *swig_obj[1] ;
26919
26920 if (!args) SWIG_fail;
26921 swig_obj[0] = args;
26922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26923 if (!SWIG_IsOK(res1)) {
26924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26925 }
26926 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 result = (PyObject *)(arg1)->GetSelf();
26930 wxPyEndAllowThreads(__tstate);
26931 if (PyErr_Occurred()) SWIG_fail;
26932 }
26933 resultobj = result;
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26941 PyObject *obj;
26942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26943 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26944 return SWIG_Py_Void();
26945 }
26946
26947 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 return SWIG_Python_InitShadowInstance(args);
26949 }
26950
26951 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26952 PyObject *resultobj = 0;
26953 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26954 int arg2 = (int) 0 ;
26955 wxPyCommandEvent *result = 0 ;
26956 int val1 ;
26957 int ecode1 = 0 ;
26958 int val2 ;
26959 int ecode2 = 0 ;
26960 PyObject * obj0 = 0 ;
26961 PyObject * obj1 = 0 ;
26962 char * kwnames[] = {
26963 (char *) "eventType",(char *) "id", NULL
26964 };
26965
26966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26967 if (obj0) {
26968 ecode1 = SWIG_AsVal_int(obj0, &val1);
26969 if (!SWIG_IsOK(ecode1)) {
26970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26971 }
26972 arg1 = static_cast< wxEventType >(val1);
26973 }
26974 if (obj1) {
26975 ecode2 = SWIG_AsVal_int(obj1, &val2);
26976 if (!SWIG_IsOK(ecode2)) {
26977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26978 }
26979 arg2 = static_cast< int >(val2);
26980 }
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26988 return resultobj;
26989 fail:
26990 return NULL;
26991 }
26992
26993
26994 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26995 PyObject *resultobj = 0;
26996 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26997 void *argp1 = 0 ;
26998 int res1 = 0 ;
26999 PyObject *swig_obj[1] ;
27000
27001 if (!args) SWIG_fail;
27002 swig_obj[0] = args;
27003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27004 if (!SWIG_IsOK(res1)) {
27005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27006 }
27007 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 delete arg1;
27011
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 resultobj = SWIG_Py_Void();
27016 return resultobj;
27017 fail:
27018 return NULL;
27019 }
27020
27021
27022 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27023 PyObject *resultobj = 0;
27024 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27025 PyObject *arg2 = (PyObject *) 0 ;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 char * kwnames[] = {
27031 (char *) "self",(char *) "self", NULL
27032 };
27033
27034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27036 if (!SWIG_IsOK(res1)) {
27037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27038 }
27039 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27040 arg2 = obj1;
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 (arg1)->SetSelf(arg2);
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 resultobj = SWIG_Py_Void();
27048 return resultobj;
27049 fail:
27050 return NULL;
27051 }
27052
27053
27054 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27055 PyObject *resultobj = 0;
27056 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27057 PyObject *result = 0 ;
27058 void *argp1 = 0 ;
27059 int res1 = 0 ;
27060 PyObject *swig_obj[1] ;
27061
27062 if (!args) SWIG_fail;
27063 swig_obj[0] = args;
27064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27065 if (!SWIG_IsOK(res1)) {
27066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27067 }
27068 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (PyObject *)(arg1)->GetSelf();
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 resultobj = result;
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27083 PyObject *obj;
27084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27085 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27086 return SWIG_Py_Void();
27087 }
27088
27089 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27090 return SWIG_Python_InitShadowInstance(args);
27091 }
27092
27093 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj = 0;
27095 wxWindow *arg1 = (wxWindow *) 0 ;
27096 wxDateTime *arg2 = 0 ;
27097 wxEventType arg3 ;
27098 wxDateEvent *result = 0 ;
27099 void *argp1 = 0 ;
27100 int res1 = 0 ;
27101 void *argp2 = 0 ;
27102 int res2 = 0 ;
27103 int val3 ;
27104 int ecode3 = 0 ;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 PyObject * obj2 = 0 ;
27108 char * kwnames[] = {
27109 (char *) "win",(char *) "dt",(char *) "type", NULL
27110 };
27111
27112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27114 if (!SWIG_IsOK(res1)) {
27115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27116 }
27117 arg1 = reinterpret_cast< wxWindow * >(argp1);
27118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27119 if (!SWIG_IsOK(res2)) {
27120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27121 }
27122 if (!argp2) {
27123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27124 }
27125 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27126 ecode3 = SWIG_AsVal_int(obj2, &val3);
27127 if (!SWIG_IsOK(ecode3)) {
27128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27129 }
27130 arg3 = static_cast< wxEventType >(val3);
27131 {
27132 PyThreadState* __tstate = wxPyBeginAllowThreads();
27133 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27134 wxPyEndAllowThreads(__tstate);
27135 if (PyErr_Occurred()) SWIG_fail;
27136 }
27137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27145 PyObject *resultobj = 0;
27146 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27147 wxDateTime *result = 0 ;
27148 void *argp1 = 0 ;
27149 int res1 = 0 ;
27150 PyObject *swig_obj[1] ;
27151
27152 if (!args) SWIG_fail;
27153 swig_obj[0] = args;
27154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27155 if (!SWIG_IsOK(res1)) {
27156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27157 }
27158 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 {
27162 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27163 result = (wxDateTime *) &_result_ref;
27164 }
27165 wxPyEndAllowThreads(__tstate);
27166 if (PyErr_Occurred()) SWIG_fail;
27167 }
27168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27169 return resultobj;
27170 fail:
27171 return NULL;
27172 }
27173
27174
27175 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27176 PyObject *resultobj = 0;
27177 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27178 wxDateTime *arg2 = 0 ;
27179 void *argp1 = 0 ;
27180 int res1 = 0 ;
27181 void *argp2 = 0 ;
27182 int res2 = 0 ;
27183 PyObject * obj0 = 0 ;
27184 PyObject * obj1 = 0 ;
27185 char * kwnames[] = {
27186 (char *) "self",(char *) "date", NULL
27187 };
27188
27189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27191 if (!SWIG_IsOK(res1)) {
27192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27193 }
27194 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27196 if (!SWIG_IsOK(res2)) {
27197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27198 }
27199 if (!argp2) {
27200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27201 }
27202 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 (arg1)->SetDate((wxDateTime const &)*arg2);
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 resultobj = SWIG_Py_Void();
27210 return resultobj;
27211 fail:
27212 return NULL;
27213 }
27214
27215
27216 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27217 PyObject *obj;
27218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27219 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27220 return SWIG_Py_Void();
27221 }
27222
27223 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 return SWIG_Python_InitShadowInstance(args);
27225 }
27226
27227 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27228 PyObject *resultobj = 0;
27229 wxPyApp *result = 0 ;
27230
27231 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = (wxPyApp *)new_wxPyApp();
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27239 return resultobj;
27240 fail:
27241 return NULL;
27242 }
27243
27244
27245 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27246 PyObject *resultobj = 0;
27247 wxPyApp *arg1 = (wxPyApp *) 0 ;
27248 void *argp1 = 0 ;
27249 int res1 = 0 ;
27250 PyObject *swig_obj[1] ;
27251
27252 if (!args) SWIG_fail;
27253 swig_obj[0] = args;
27254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27257 }
27258 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 delete arg1;
27262
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 resultobj = SWIG_Py_Void();
27267 return resultobj;
27268 fail:
27269 return NULL;
27270 }
27271
27272
27273 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27274 PyObject *resultobj = 0;
27275 wxPyApp *arg1 = (wxPyApp *) 0 ;
27276 PyObject *arg2 = (PyObject *) 0 ;
27277 PyObject *arg3 = (PyObject *) 0 ;
27278 bool arg4 ;
27279 void *argp1 = 0 ;
27280 int res1 = 0 ;
27281 bool val4 ;
27282 int ecode4 = 0 ;
27283 PyObject * obj0 = 0 ;
27284 PyObject * obj1 = 0 ;
27285 PyObject * obj2 = 0 ;
27286 PyObject * obj3 = 0 ;
27287 char * kwnames[] = {
27288 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27289 };
27290
27291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27293 if (!SWIG_IsOK(res1)) {
27294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27295 }
27296 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27297 arg2 = obj1;
27298 arg3 = obj2;
27299 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27300 if (!SWIG_IsOK(ecode4)) {
27301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27302 }
27303 arg4 = static_cast< bool >(val4);
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 resultobj = SWIG_Py_Void();
27311 return resultobj;
27312 fail:
27313 return NULL;
27314 }
27315
27316
27317 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27318 PyObject *resultobj = 0;
27319 wxPyApp *arg1 = (wxPyApp *) 0 ;
27320 wxString result;
27321 void *argp1 = 0 ;
27322 int res1 = 0 ;
27323 PyObject *swig_obj[1] ;
27324
27325 if (!args) SWIG_fail;
27326 swig_obj[0] = args;
27327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27328 if (!SWIG_IsOK(res1)) {
27329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27330 }
27331 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27332 {
27333 PyThreadState* __tstate = wxPyBeginAllowThreads();
27334 result = ((wxPyApp const *)arg1)->GetAppName();
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 {
27339 #if wxUSE_UNICODE
27340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27341 #else
27342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27343 #endif
27344 }
27345 return resultobj;
27346 fail:
27347 return NULL;
27348 }
27349
27350
27351 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27352 PyObject *resultobj = 0;
27353 wxPyApp *arg1 = (wxPyApp *) 0 ;
27354 wxString *arg2 = 0 ;
27355 void *argp1 = 0 ;
27356 int res1 = 0 ;
27357 bool temp2 = false ;
27358 PyObject * obj0 = 0 ;
27359 PyObject * obj1 = 0 ;
27360 char * kwnames[] = {
27361 (char *) "self",(char *) "name", NULL
27362 };
27363
27364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27368 }
27369 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27370 {
27371 arg2 = wxString_in_helper(obj1);
27372 if (arg2 == NULL) SWIG_fail;
27373 temp2 = true;
27374 }
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 (arg1)->SetAppName((wxString const &)*arg2);
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 resultobj = SWIG_Py_Void();
27382 {
27383 if (temp2)
27384 delete arg2;
27385 }
27386 return resultobj;
27387 fail:
27388 {
27389 if (temp2)
27390 delete arg2;
27391 }
27392 return NULL;
27393 }
27394
27395
27396 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27397 PyObject *resultobj = 0;
27398 wxPyApp *arg1 = (wxPyApp *) 0 ;
27399 wxString result;
27400 void *argp1 = 0 ;
27401 int res1 = 0 ;
27402 PyObject *swig_obj[1] ;
27403
27404 if (!args) SWIG_fail;
27405 swig_obj[0] = args;
27406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27407 if (!SWIG_IsOK(res1)) {
27408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27409 }
27410 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = ((wxPyApp const *)arg1)->GetClassName();
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 {
27418 #if wxUSE_UNICODE
27419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27420 #else
27421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27422 #endif
27423 }
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj = 0;
27432 wxPyApp *arg1 = (wxPyApp *) 0 ;
27433 wxString *arg2 = 0 ;
27434 void *argp1 = 0 ;
27435 int res1 = 0 ;
27436 bool temp2 = false ;
27437 PyObject * obj0 = 0 ;
27438 PyObject * obj1 = 0 ;
27439 char * kwnames[] = {
27440 (char *) "self",(char *) "name", NULL
27441 };
27442
27443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27445 if (!SWIG_IsOK(res1)) {
27446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27447 }
27448 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27449 {
27450 arg2 = wxString_in_helper(obj1);
27451 if (arg2 == NULL) SWIG_fail;
27452 temp2 = true;
27453 }
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 (arg1)->SetClassName((wxString const &)*arg2);
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 resultobj = SWIG_Py_Void();
27461 {
27462 if (temp2)
27463 delete arg2;
27464 }
27465 return resultobj;
27466 fail:
27467 {
27468 if (temp2)
27469 delete arg2;
27470 }
27471 return NULL;
27472 }
27473
27474
27475 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476 PyObject *resultobj = 0;
27477 wxPyApp *arg1 = (wxPyApp *) 0 ;
27478 wxString *result = 0 ;
27479 void *argp1 = 0 ;
27480 int res1 = 0 ;
27481 PyObject *swig_obj[1] ;
27482
27483 if (!args) SWIG_fail;
27484 swig_obj[0] = args;
27485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27486 if (!SWIG_IsOK(res1)) {
27487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27488 }
27489 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 {
27493 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27494 result = (wxString *) &_result_ref;
27495 }
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 {
27500 #if wxUSE_UNICODE
27501 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27502 #else
27503 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27504 #endif
27505 }
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = 0;
27514 wxPyApp *arg1 = (wxPyApp *) 0 ;
27515 wxString *arg2 = 0 ;
27516 void *argp1 = 0 ;
27517 int res1 = 0 ;
27518 bool temp2 = false ;
27519 PyObject * obj0 = 0 ;
27520 PyObject * obj1 = 0 ;
27521 char * kwnames[] = {
27522 (char *) "self",(char *) "name", NULL
27523 };
27524
27525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27527 if (!SWIG_IsOK(res1)) {
27528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27529 }
27530 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27531 {
27532 arg2 = wxString_in_helper(obj1);
27533 if (arg2 == NULL) SWIG_fail;
27534 temp2 = true;
27535 }
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 (arg1)->SetVendorName((wxString const &)*arg2);
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_Py_Void();
27543 {
27544 if (temp2)
27545 delete arg2;
27546 }
27547 return resultobj;
27548 fail:
27549 {
27550 if (temp2)
27551 delete arg2;
27552 }
27553 return NULL;
27554 }
27555
27556
27557 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27558 PyObject *resultobj = 0;
27559 wxPyApp *arg1 = (wxPyApp *) 0 ;
27560 wxAppTraits *result = 0 ;
27561 void *argp1 = 0 ;
27562 int res1 = 0 ;
27563 PyObject *swig_obj[1] ;
27564
27565 if (!args) SWIG_fail;
27566 swig_obj[0] = args;
27567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27568 if (!SWIG_IsOK(res1)) {
27569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27570 }
27571 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27572 {
27573 PyThreadState* __tstate = wxPyBeginAllowThreads();
27574 result = (wxAppTraits *)(arg1)->GetTraits();
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27586 PyObject *resultobj = 0;
27587 wxPyApp *arg1 = (wxPyApp *) 0 ;
27588 void *argp1 = 0 ;
27589 int res1 = 0 ;
27590 PyObject *swig_obj[1] ;
27591
27592 if (!args) SWIG_fail;
27593 swig_obj[0] = args;
27594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27595 if (!SWIG_IsOK(res1)) {
27596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27597 }
27598 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27599 {
27600 PyThreadState* __tstate = wxPyBeginAllowThreads();
27601 (arg1)->ProcessPendingEvents();
27602 wxPyEndAllowThreads(__tstate);
27603 if (PyErr_Occurred()) SWIG_fail;
27604 }
27605 resultobj = SWIG_Py_Void();
27606 return resultobj;
27607 fail:
27608 return NULL;
27609 }
27610
27611
27612 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27613 PyObject *resultobj = 0;
27614 wxPyApp *arg1 = (wxPyApp *) 0 ;
27615 bool arg2 = (bool) false ;
27616 bool result;
27617 void *argp1 = 0 ;
27618 int res1 = 0 ;
27619 bool val2 ;
27620 int ecode2 = 0 ;
27621 PyObject * obj0 = 0 ;
27622 PyObject * obj1 = 0 ;
27623 char * kwnames[] = {
27624 (char *) "self",(char *) "onlyIfNeeded", NULL
27625 };
27626
27627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27631 }
27632 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27633 if (obj1) {
27634 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27635 if (!SWIG_IsOK(ecode2)) {
27636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27637 }
27638 arg2 = static_cast< bool >(val2);
27639 }
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (bool)(arg1)->Yield(arg2);
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 {
27647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27648 }
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27656 PyObject *resultobj = 0;
27657 wxPyApp *arg1 = (wxPyApp *) 0 ;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 PyObject *swig_obj[1] ;
27661
27662 if (!args) SWIG_fail;
27663 swig_obj[0] = args;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27667 }
27668 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 (arg1)->WakeUpIdle();
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 resultobj = SWIG_Py_Void();
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27683 PyObject *resultobj = 0;
27684 bool result;
27685
27686 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27687 {
27688 PyThreadState* __tstate = wxPyBeginAllowThreads();
27689 result = (bool)wxPyApp::IsMainLoopRunning();
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 {
27694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27695 }
27696 return resultobj;
27697 fail:
27698 return NULL;
27699 }
27700
27701
27702 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27703 PyObject *resultobj = 0;
27704 wxPyApp *arg1 = (wxPyApp *) 0 ;
27705 int result;
27706 void *argp1 = 0 ;
27707 int res1 = 0 ;
27708 PyObject *swig_obj[1] ;
27709
27710 if (!args) SWIG_fail;
27711 swig_obj[0] = args;
27712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27715 }
27716 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (int)(arg1)->MainLoop();
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_From_int(static_cast< int >(result));
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27731 PyObject *resultobj = 0;
27732 wxPyApp *arg1 = (wxPyApp *) 0 ;
27733 void *argp1 = 0 ;
27734 int res1 = 0 ;
27735 PyObject *swig_obj[1] ;
27736
27737 if (!args) SWIG_fail;
27738 swig_obj[0] = args;
27739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27740 if (!SWIG_IsOK(res1)) {
27741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27742 }
27743 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 (arg1)->Exit();
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 resultobj = SWIG_Py_Void();
27751 return resultobj;
27752 fail:
27753 return NULL;
27754 }
27755
27756
27757 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27758 PyObject *resultobj = 0;
27759 wxPyApp *arg1 = (wxPyApp *) 0 ;
27760 wxLayoutDirection result;
27761 void *argp1 = 0 ;
27762 int res1 = 0 ;
27763 PyObject *swig_obj[1] ;
27764
27765 if (!args) SWIG_fail;
27766 swig_obj[0] = args;
27767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27768 if (!SWIG_IsOK(res1)) {
27769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27770 }
27771 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = ((wxPyApp const *)arg1)->GetLayoutDirection();
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27786 PyObject *resultobj = 0;
27787 wxPyApp *arg1 = (wxPyApp *) 0 ;
27788 void *argp1 = 0 ;
27789 int res1 = 0 ;
27790 PyObject *swig_obj[1] ;
27791
27792 if (!args) SWIG_fail;
27793 swig_obj[0] = args;
27794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27795 if (!SWIG_IsOK(res1)) {
27796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27797 }
27798 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27799 {
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 (arg1)->ExitMainLoop();
27802 wxPyEndAllowThreads(__tstate);
27803 if (PyErr_Occurred()) SWIG_fail;
27804 }
27805 resultobj = SWIG_Py_Void();
27806 return resultobj;
27807 fail:
27808 return NULL;
27809 }
27810
27811
27812 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27813 PyObject *resultobj = 0;
27814 wxPyApp *arg1 = (wxPyApp *) 0 ;
27815 bool result;
27816 void *argp1 = 0 ;
27817 int res1 = 0 ;
27818 PyObject *swig_obj[1] ;
27819
27820 if (!args) SWIG_fail;
27821 swig_obj[0] = args;
27822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27823 if (!SWIG_IsOK(res1)) {
27824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27825 }
27826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27827 {
27828 PyThreadState* __tstate = wxPyBeginAllowThreads();
27829 result = (bool)(arg1)->Pending();
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 {
27834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27835 }
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27843 PyObject *resultobj = 0;
27844 wxPyApp *arg1 = (wxPyApp *) 0 ;
27845 bool result;
27846 void *argp1 = 0 ;
27847 int res1 = 0 ;
27848 PyObject *swig_obj[1] ;
27849
27850 if (!args) SWIG_fail;
27851 swig_obj[0] = args;
27852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27855 }
27856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27857 {
27858 PyThreadState* __tstate = wxPyBeginAllowThreads();
27859 result = (bool)(arg1)->Dispatch();
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 {
27864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27865 }
27866 return resultobj;
27867 fail:
27868 return NULL;
27869 }
27870
27871
27872 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27873 PyObject *resultobj = 0;
27874 wxPyApp *arg1 = (wxPyApp *) 0 ;
27875 bool result;
27876 void *argp1 = 0 ;
27877 int res1 = 0 ;
27878 PyObject *swig_obj[1] ;
27879
27880 if (!args) SWIG_fail;
27881 swig_obj[0] = args;
27882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27883 if (!SWIG_IsOK(res1)) {
27884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27885 }
27886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 result = (bool)(arg1)->ProcessIdle();
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 {
27894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj = 0;
27904 wxPyApp *arg1 = (wxPyApp *) 0 ;
27905 wxWindow *arg2 = (wxWindow *) 0 ;
27906 wxIdleEvent *arg3 = 0 ;
27907 bool result;
27908 void *argp1 = 0 ;
27909 int res1 = 0 ;
27910 void *argp2 = 0 ;
27911 int res2 = 0 ;
27912 void *argp3 = 0 ;
27913 int res3 = 0 ;
27914 PyObject * obj0 = 0 ;
27915 PyObject * obj1 = 0 ;
27916 PyObject * obj2 = 0 ;
27917 char * kwnames[] = {
27918 (char *) "self",(char *) "win",(char *) "event", NULL
27919 };
27920
27921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27923 if (!SWIG_IsOK(res1)) {
27924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27925 }
27926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27928 if (!SWIG_IsOK(res2)) {
27929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27930 }
27931 arg2 = reinterpret_cast< wxWindow * >(argp2);
27932 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27933 if (!SWIG_IsOK(res3)) {
27934 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27935 }
27936 if (!argp3) {
27937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27938 }
27939 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 {
27947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27948 }
27949 return resultobj;
27950 fail:
27951 return NULL;
27952 }
27953
27954
27955 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27956 PyObject *resultobj = 0;
27957 wxPyApp *arg1 = (wxPyApp *) 0 ;
27958 bool result;
27959 void *argp1 = 0 ;
27960 int res1 = 0 ;
27961 PyObject *swig_obj[1] ;
27962
27963 if (!args) SWIG_fail;
27964 swig_obj[0] = args;
27965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27966 if (!SWIG_IsOK(res1)) {
27967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27968 }
27969 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 result = (bool)((wxPyApp const *)arg1)->IsActive();
27973 wxPyEndAllowThreads(__tstate);
27974 if (PyErr_Occurred()) SWIG_fail;
27975 }
27976 {
27977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27978 }
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxPyApp *arg1 = (wxPyApp *) 0 ;
27988 wxWindow *arg2 = (wxWindow *) 0 ;
27989 void *argp1 = 0 ;
27990 int res1 = 0 ;
27991 void *argp2 = 0 ;
27992 int res2 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 PyObject * obj1 = 0 ;
27995 char * kwnames[] = {
27996 (char *) "self",(char *) "win", NULL
27997 };
27998
27999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28003 }
28004 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28006 if (!SWIG_IsOK(res2)) {
28007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28008 }
28009 arg2 = reinterpret_cast< wxWindow * >(argp2);
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 (arg1)->SetTopWindow(arg2);
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = SWIG_Py_Void();
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28024 PyObject *resultobj = 0;
28025 wxPyApp *arg1 = (wxPyApp *) 0 ;
28026 wxWindow *result = 0 ;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 PyObject *swig_obj[1] ;
28030
28031 if (!args) SWIG_fail;
28032 swig_obj[0] = args;
28033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28034 if (!SWIG_IsOK(res1)) {
28035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28036 }
28037 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = wxPyMake_wxObject(result, (bool)0);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28054 PyObject *resultobj = 0;
28055 wxPyApp *arg1 = (wxPyApp *) 0 ;
28056 bool arg2 ;
28057 void *argp1 = 0 ;
28058 int res1 = 0 ;
28059 bool val2 ;
28060 int ecode2 = 0 ;
28061 PyObject * obj0 = 0 ;
28062 PyObject * obj1 = 0 ;
28063 char * kwnames[] = {
28064 (char *) "self",(char *) "flag", NULL
28065 };
28066
28067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28069 if (!SWIG_IsOK(res1)) {
28070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28071 }
28072 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28073 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28074 if (!SWIG_IsOK(ecode2)) {
28075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28076 }
28077 arg2 = static_cast< bool >(val2);
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 (arg1)->SetExitOnFrameDelete(arg2);
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 resultobj = SWIG_Py_Void();
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28092 PyObject *resultobj = 0;
28093 wxPyApp *arg1 = (wxPyApp *) 0 ;
28094 bool result;
28095 void *argp1 = 0 ;
28096 int res1 = 0 ;
28097 PyObject *swig_obj[1] ;
28098
28099 if (!args) SWIG_fail;
28100 swig_obj[0] = args;
28101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28102 if (!SWIG_IsOK(res1)) {
28103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28104 }
28105 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 {
28113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28122 PyObject *resultobj = 0;
28123 wxPyApp *arg1 = (wxPyApp *) 0 ;
28124 bool arg2 ;
28125 void *argp1 = 0 ;
28126 int res1 = 0 ;
28127 bool val2 ;
28128 int ecode2 = 0 ;
28129 PyObject * obj0 = 0 ;
28130 PyObject * obj1 = 0 ;
28131 char * kwnames[] = {
28132 (char *) "self",(char *) "flag", NULL
28133 };
28134
28135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28137 if (!SWIG_IsOK(res1)) {
28138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28139 }
28140 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28142 if (!SWIG_IsOK(ecode2)) {
28143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28144 }
28145 arg2 = static_cast< bool >(val2);
28146 {
28147 PyThreadState* __tstate = wxPyBeginAllowThreads();
28148 (arg1)->SetUseBestVisual(arg2);
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 resultobj = SWIG_Py_Void();
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28160 PyObject *resultobj = 0;
28161 wxPyApp *arg1 = (wxPyApp *) 0 ;
28162 bool result;
28163 void *argp1 = 0 ;
28164 int res1 = 0 ;
28165 PyObject *swig_obj[1] ;
28166
28167 if (!args) SWIG_fail;
28168 swig_obj[0] = args;
28169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28170 if (!SWIG_IsOK(res1)) {
28171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28172 }
28173 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 {
28181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28182 }
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28190 PyObject *resultobj = 0;
28191 wxPyApp *arg1 = (wxPyApp *) 0 ;
28192 int arg2 ;
28193 void *argp1 = 0 ;
28194 int res1 = 0 ;
28195 int val2 ;
28196 int ecode2 = 0 ;
28197 PyObject * obj0 = 0 ;
28198 PyObject * obj1 = 0 ;
28199 char * kwnames[] = {
28200 (char *) "self",(char *) "mode", NULL
28201 };
28202
28203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28205 if (!SWIG_IsOK(res1)) {
28206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28207 }
28208 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28209 ecode2 = SWIG_AsVal_int(obj1, &val2);
28210 if (!SWIG_IsOK(ecode2)) {
28211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28212 }
28213 arg2 = static_cast< int >(val2);
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 (arg1)->SetPrintMode(arg2);
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 resultobj = SWIG_Py_Void();
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28228 PyObject *resultobj = 0;
28229 wxPyApp *arg1 = (wxPyApp *) 0 ;
28230 int result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 PyObject *swig_obj[1] ;
28234
28235 if (!args) SWIG_fail;
28236 swig_obj[0] = args;
28237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28238 if (!SWIG_IsOK(res1)) {
28239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28240 }
28241 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 resultobj = SWIG_From_int(static_cast< int >(result));
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28256 PyObject *resultobj = 0;
28257 wxPyApp *arg1 = (wxPyApp *) 0 ;
28258 int arg2 ;
28259 void *argp1 = 0 ;
28260 int res1 = 0 ;
28261 int val2 ;
28262 int ecode2 = 0 ;
28263 PyObject * obj0 = 0 ;
28264 PyObject * obj1 = 0 ;
28265 char * kwnames[] = {
28266 (char *) "self",(char *) "mode", NULL
28267 };
28268
28269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28271 if (!SWIG_IsOK(res1)) {
28272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28273 }
28274 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28275 ecode2 = SWIG_AsVal_int(obj1, &val2);
28276 if (!SWIG_IsOK(ecode2)) {
28277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28278 }
28279 arg2 = static_cast< int >(val2);
28280 {
28281 PyThreadState* __tstate = wxPyBeginAllowThreads();
28282 (arg1)->SetAssertMode(arg2);
28283 wxPyEndAllowThreads(__tstate);
28284 if (PyErr_Occurred()) SWIG_fail;
28285 }
28286 resultobj = SWIG_Py_Void();
28287 return resultobj;
28288 fail:
28289 return NULL;
28290 }
28291
28292
28293 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28294 PyObject *resultobj = 0;
28295 wxPyApp *arg1 = (wxPyApp *) 0 ;
28296 int result;
28297 void *argp1 = 0 ;
28298 int res1 = 0 ;
28299 PyObject *swig_obj[1] ;
28300
28301 if (!args) SWIG_fail;
28302 swig_obj[0] = args;
28303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28304 if (!SWIG_IsOK(res1)) {
28305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28306 }
28307 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (int)(arg1)->GetAssertMode();
28311 wxPyEndAllowThreads(__tstate);
28312 if (PyErr_Occurred()) SWIG_fail;
28313 }
28314 resultobj = SWIG_From_int(static_cast< int >(result));
28315 return resultobj;
28316 fail:
28317 return NULL;
28318 }
28319
28320
28321 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28322 PyObject *resultobj = 0;
28323 bool result;
28324
28325 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28326 {
28327 PyThreadState* __tstate = wxPyBeginAllowThreads();
28328 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28329 wxPyEndAllowThreads(__tstate);
28330 if (PyErr_Occurred()) SWIG_fail;
28331 }
28332 {
28333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28334 }
28335 return resultobj;
28336 fail:
28337 return NULL;
28338 }
28339
28340
28341 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28342 PyObject *resultobj = 0;
28343 long result;
28344
28345 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28346 {
28347 PyThreadState* __tstate = wxPyBeginAllowThreads();
28348 result = (long)wxPyApp::GetMacAboutMenuItemId();
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 resultobj = SWIG_From_long(static_cast< long >(result));
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 PyObject *resultobj = 0;
28361 long result;
28362
28363 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28367 wxPyEndAllowThreads(__tstate);
28368 if (PyErr_Occurred()) SWIG_fail;
28369 }
28370 resultobj = SWIG_From_long(static_cast< long >(result));
28371 return resultobj;
28372 fail:
28373 return NULL;
28374 }
28375
28376
28377 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28378 PyObject *resultobj = 0;
28379 long result;
28380
28381 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = (long)wxPyApp::GetMacExitMenuItemId();
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 resultobj = SWIG_From_long(static_cast< long >(result));
28389 return resultobj;
28390 fail:
28391 return NULL;
28392 }
28393
28394
28395 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28396 PyObject *resultobj = 0;
28397 wxString result;
28398
28399 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28400 {
28401 PyThreadState* __tstate = wxPyBeginAllowThreads();
28402 result = wxPyApp::GetMacHelpMenuTitleName();
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 {
28407 #if wxUSE_UNICODE
28408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28409 #else
28410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28411 #endif
28412 }
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28420 PyObject *resultobj = 0;
28421 bool arg1 ;
28422 bool val1 ;
28423 int ecode1 = 0 ;
28424 PyObject * obj0 = 0 ;
28425 char * kwnames[] = {
28426 (char *) "val", NULL
28427 };
28428
28429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28430 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28431 if (!SWIG_IsOK(ecode1)) {
28432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28433 }
28434 arg1 = static_cast< bool >(val1);
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 resultobj = SWIG_Py_Void();
28442 return resultobj;
28443 fail:
28444 return NULL;
28445 }
28446
28447
28448 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28449 PyObject *resultobj = 0;
28450 long arg1 ;
28451 long val1 ;
28452 int ecode1 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 char * kwnames[] = {
28455 (char *) "val", NULL
28456 };
28457
28458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28459 ecode1 = SWIG_AsVal_long(obj0, &val1);
28460 if (!SWIG_IsOK(ecode1)) {
28461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28462 }
28463 arg1 = static_cast< long >(val1);
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 wxPyApp::SetMacAboutMenuItemId(arg1);
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 resultobj = SWIG_Py_Void();
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28478 PyObject *resultobj = 0;
28479 long arg1 ;
28480 long val1 ;
28481 int ecode1 = 0 ;
28482 PyObject * obj0 = 0 ;
28483 char * kwnames[] = {
28484 (char *) "val", NULL
28485 };
28486
28487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28488 ecode1 = SWIG_AsVal_long(obj0, &val1);
28489 if (!SWIG_IsOK(ecode1)) {
28490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28491 }
28492 arg1 = static_cast< long >(val1);
28493 {
28494 PyThreadState* __tstate = wxPyBeginAllowThreads();
28495 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28496 wxPyEndAllowThreads(__tstate);
28497 if (PyErr_Occurred()) SWIG_fail;
28498 }
28499 resultobj = SWIG_Py_Void();
28500 return resultobj;
28501 fail:
28502 return NULL;
28503 }
28504
28505
28506 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28507 PyObject *resultobj = 0;
28508 long arg1 ;
28509 long val1 ;
28510 int ecode1 = 0 ;
28511 PyObject * obj0 = 0 ;
28512 char * kwnames[] = {
28513 (char *) "val", NULL
28514 };
28515
28516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28517 ecode1 = SWIG_AsVal_long(obj0, &val1);
28518 if (!SWIG_IsOK(ecode1)) {
28519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28520 }
28521 arg1 = static_cast< long >(val1);
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 wxPyApp::SetMacExitMenuItemId(arg1);
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 resultobj = SWIG_Py_Void();
28529 return resultobj;
28530 fail:
28531 return NULL;
28532 }
28533
28534
28535 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28536 PyObject *resultobj = 0;
28537 wxString *arg1 = 0 ;
28538 bool temp1 = false ;
28539 PyObject * obj0 = 0 ;
28540 char * kwnames[] = {
28541 (char *) "val", NULL
28542 };
28543
28544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28545 {
28546 arg1 = wxString_in_helper(obj0);
28547 if (arg1 == NULL) SWIG_fail;
28548 temp1 = true;
28549 }
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 resultobj = SWIG_Py_Void();
28557 {
28558 if (temp1)
28559 delete arg1;
28560 }
28561 return resultobj;
28562 fail:
28563 {
28564 if (temp1)
28565 delete arg1;
28566 }
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28572 PyObject *resultobj = 0;
28573 wxPyApp *arg1 = (wxPyApp *) 0 ;
28574 void *argp1 = 0 ;
28575 int res1 = 0 ;
28576 PyObject *swig_obj[1] ;
28577
28578 if (!args) SWIG_fail;
28579 swig_obj[0] = args;
28580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28581 if (!SWIG_IsOK(res1)) {
28582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28583 }
28584 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 (arg1)->_BootstrapApp();
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 resultobj = SWIG_Py_Void();
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28599 PyObject *resultobj = 0;
28600 int result;
28601
28602 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (int)wxPyApp::GetComCtl32Version();
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_From_int(static_cast< int >(result));
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 bool result;
28619
28620 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 result = (bool)wxPyApp_IsDisplayAvailable();
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 {
28628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28629 }
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28637 PyObject *obj;
28638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28640 return SWIG_Py_Void();
28641 }
28642
28643 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28644 return SWIG_Python_InitShadowInstance(args);
28645 }
28646
28647 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *resultobj = 0;
28649
28650 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 wxExit();
28654 wxPyEndAllowThreads(__tstate);
28655 if (PyErr_Occurred()) SWIG_fail;
28656 }
28657 resultobj = SWIG_Py_Void();
28658 return resultobj;
28659 fail:
28660 return NULL;
28661 }
28662
28663
28664 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28665 PyObject *resultobj = 0;
28666 bool result;
28667
28668 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = (bool)wxYield();
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 {
28676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28677 }
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 bool result;
28687
28688 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 result = (bool)wxYieldIfNeeded();
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 {
28696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28697 }
28698 return resultobj;
28699 fail:
28700 return NULL;
28701 }
28702
28703
28704 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28705 PyObject *resultobj = 0;
28706 wxWindow *arg1 = (wxWindow *) NULL ;
28707 bool arg2 = (bool) false ;
28708 bool result;
28709 void *argp1 = 0 ;
28710 int res1 = 0 ;
28711 bool val2 ;
28712 int ecode2 = 0 ;
28713 PyObject * obj0 = 0 ;
28714 PyObject * obj1 = 0 ;
28715 char * kwnames[] = {
28716 (char *) "win",(char *) "onlyIfNeeded", NULL
28717 };
28718
28719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28720 if (obj0) {
28721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28722 if (!SWIG_IsOK(res1)) {
28723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28724 }
28725 arg1 = reinterpret_cast< wxWindow * >(argp1);
28726 }
28727 if (obj1) {
28728 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28729 if (!SWIG_IsOK(ecode2)) {
28730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28731 }
28732 arg2 = static_cast< bool >(val2);
28733 }
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = (bool)wxSafeYield(arg1,arg2);
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 {
28741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28742 }
28743 return resultobj;
28744 fail:
28745 return NULL;
28746 }
28747
28748
28749 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28750 PyObject *resultobj = 0;
28751
28752 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28753 {
28754 PyThreadState* __tstate = wxPyBeginAllowThreads();
28755 wxWakeUpIdle();
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 resultobj = SWIG_Py_Void();
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj = 0;
28768 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28769 wxEvent *arg2 = 0 ;
28770 void *argp1 = 0 ;
28771 int res1 = 0 ;
28772 void *argp2 = 0 ;
28773 int res2 = 0 ;
28774 PyObject * obj0 = 0 ;
28775 PyObject * obj1 = 0 ;
28776 char * kwnames[] = {
28777 (char *) "dest",(char *) "event", NULL
28778 };
28779
28780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28782 if (!SWIG_IsOK(res1)) {
28783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28784 }
28785 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28786 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28787 if (!SWIG_IsOK(res2)) {
28788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28789 }
28790 if (!argp2) {
28791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28792 }
28793 arg2 = reinterpret_cast< wxEvent * >(argp2);
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 wxPostEvent(arg1,*arg2);
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 resultobj = SWIG_Py_Void();
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28808 PyObject *resultobj = 0;
28809
28810 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 wxApp_CleanUp();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_Py_Void();
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxPyApp *result = 0 ;
28827
28828 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = (wxPyApp *)wxPyGetApp();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 {
28836 resultobj = wxPyMake_wxObject(result, 0);
28837 }
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28845 PyObject *resultobj = 0;
28846 char *arg1 = (char *) 0 ;
28847 int res1 ;
28848 char *buf1 = 0 ;
28849 int alloc1 = 0 ;
28850 PyObject * obj0 = 0 ;
28851 char * kwnames[] = {
28852 (char *) "encoding", NULL
28853 };
28854
28855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28856 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28857 if (!SWIG_IsOK(res1)) {
28858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28859 }
28860 arg1 = buf1;
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 wxSetDefaultPyEncoding((char const *)arg1);
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 resultobj = SWIG_Py_Void();
28868 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28869 return resultobj;
28870 fail:
28871 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28872 return NULL;
28873 }
28874
28875
28876 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28877 PyObject *resultobj = 0;
28878 char *result = 0 ;
28879
28880 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 result = (char *)wxGetDefaultPyEncoding();
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_FromCharPtr(result);
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28895 PyObject *resultobj = 0;
28896 wxEventLoop *result = 0 ;
28897
28898 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 result = (wxEventLoop *)new wxEventLoop();
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28913 PyObject *resultobj = 0;
28914 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject *swig_obj[1] ;
28918
28919 if (!args) SWIG_fail;
28920 swig_obj[0] = args;
28921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28922 if (!SWIG_IsOK(res1)) {
28923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28924 }
28925 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 delete arg1;
28929
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = SWIG_Py_Void();
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28941 PyObject *resultobj = 0;
28942 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28943 int result;
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_wxEventLoop, 0 | 0 );
28951 if (!SWIG_IsOK(res1)) {
28952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28953 }
28954 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 result = (int)(arg1)->Run();
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 resultobj = SWIG_From_int(static_cast< int >(result));
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj = 0;
28970 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28971 int arg2 = (int) 0 ;
28972 void *argp1 = 0 ;
28973 int res1 = 0 ;
28974 int val2 ;
28975 int ecode2 = 0 ;
28976 PyObject * obj0 = 0 ;
28977 PyObject * obj1 = 0 ;
28978 char * kwnames[] = {
28979 (char *) "self",(char *) "rc", NULL
28980 };
28981
28982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28984 if (!SWIG_IsOK(res1)) {
28985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28986 }
28987 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28988 if (obj1) {
28989 ecode2 = SWIG_AsVal_int(obj1, &val2);
28990 if (!SWIG_IsOK(ecode2)) {
28991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28992 }
28993 arg2 = static_cast< int >(val2);
28994 }
28995 {
28996 PyThreadState* __tstate = wxPyBeginAllowThreads();
28997 (arg1)->Exit(arg2);
28998 wxPyEndAllowThreads(__tstate);
28999 if (PyErr_Occurred()) SWIG_fail;
29000 }
29001 resultobj = SWIG_Py_Void();
29002 return resultobj;
29003 fail:
29004 return NULL;
29005 }
29006
29007
29008 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29009 PyObject *resultobj = 0;
29010 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29011 bool result;
29012 void *argp1 = 0 ;
29013 int res1 = 0 ;
29014 PyObject *swig_obj[1] ;
29015
29016 if (!args) SWIG_fail;
29017 swig_obj[0] = args;
29018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29019 if (!SWIG_IsOK(res1)) {
29020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29021 }
29022 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 result = (bool)((wxEventLoop const *)arg1)->Pending();
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 {
29030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29031 }
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29039 PyObject *resultobj = 0;
29040 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29041 bool result;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject *swig_obj[1] ;
29045
29046 if (!args) SWIG_fail;
29047 swig_obj[0] = args;
29048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29051 }
29052 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (bool)(arg1)->Dispatch();
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 {
29060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29061 }
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29069 PyObject *resultobj = 0;
29070 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29071 bool result;
29072 void *argp1 = 0 ;
29073 int res1 = 0 ;
29074 PyObject *swig_obj[1] ;
29075
29076 if (!args) SWIG_fail;
29077 swig_obj[0] = args;
29078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29079 if (!SWIG_IsOK(res1)) {
29080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29081 }
29082 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 {
29090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29091 }
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29099 PyObject *resultobj = 0;
29100 wxEventLoop *result = 0 ;
29101
29102 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29103 {
29104 PyThreadState* __tstate = wxPyBeginAllowThreads();
29105 result = (wxEventLoop *)wxEventLoop::GetActive();
29106 wxPyEndAllowThreads(__tstate);
29107 if (PyErr_Occurred()) SWIG_fail;
29108 }
29109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29117 PyObject *resultobj = 0;
29118 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29119 void *argp1 = 0 ;
29120 int res1 = 0 ;
29121 PyObject * obj0 = 0 ;
29122 char * kwnames[] = {
29123 (char *) "loop", NULL
29124 };
29125
29126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29128 if (!SWIG_IsOK(res1)) {
29129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29130 }
29131 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29132 {
29133 PyThreadState* __tstate = wxPyBeginAllowThreads();
29134 wxEventLoop::SetActive(arg1);
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 resultobj = SWIG_Py_Void();
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29146 PyObject *obj;
29147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29148 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29149 return SWIG_Py_Void();
29150 }
29151
29152 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29153 return SWIG_Python_InitShadowInstance(args);
29154 }
29155
29156 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29157 PyObject *resultobj = 0;
29158 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29159 wxEventLoopActivator *result = 0 ;
29160 void *argp1 = 0 ;
29161 int res1 = 0 ;
29162 PyObject * obj0 = 0 ;
29163 char * kwnames[] = {
29164 (char *) "evtLoop", NULL
29165 };
29166
29167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29169 if (!SWIG_IsOK(res1)) {
29170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29171 }
29172 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29173 {
29174 PyThreadState* __tstate = wxPyBeginAllowThreads();
29175 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29187 PyObject *resultobj = 0;
29188 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29189 void *argp1 = 0 ;
29190 int res1 = 0 ;
29191 PyObject *swig_obj[1] ;
29192
29193 if (!args) SWIG_fail;
29194 swig_obj[0] = args;
29195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29196 if (!SWIG_IsOK(res1)) {
29197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29198 }
29199 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 delete arg1;
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 resultobj = SWIG_Py_Void();
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29215 PyObject *obj;
29216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29217 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29218 return SWIG_Py_Void();
29219 }
29220
29221 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 return SWIG_Python_InitShadowInstance(args);
29223 }
29224
29225 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29226 PyObject *resultobj = 0;
29227 int arg1 = (int) 0 ;
29228 int arg2 = (int) 0 ;
29229 int arg3 = (int) 0 ;
29230 wxAcceleratorEntry *result = 0 ;
29231 int val1 ;
29232 int ecode1 = 0 ;
29233 int val2 ;
29234 int ecode2 = 0 ;
29235 int val3 ;
29236 int ecode3 = 0 ;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 PyObject * obj2 = 0 ;
29240 char * kwnames[] = {
29241 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29242 };
29243
29244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29245 if (obj0) {
29246 ecode1 = SWIG_AsVal_int(obj0, &val1);
29247 if (!SWIG_IsOK(ecode1)) {
29248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29249 }
29250 arg1 = static_cast< int >(val1);
29251 }
29252 if (obj1) {
29253 ecode2 = SWIG_AsVal_int(obj1, &val2);
29254 if (!SWIG_IsOK(ecode2)) {
29255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29256 }
29257 arg2 = static_cast< int >(val2);
29258 }
29259 if (obj2) {
29260 ecode3 = SWIG_AsVal_int(obj2, &val3);
29261 if (!SWIG_IsOK(ecode3)) {
29262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29263 }
29264 arg3 = static_cast< int >(val3);
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 PyObject *swig_obj[1] ;
29285
29286 if (!args) SWIG_fail;
29287 swig_obj[0] = args;
29288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29291 }
29292 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29293 {
29294 PyThreadState* __tstate = wxPyBeginAllowThreads();
29295 delete arg1;
29296
29297 wxPyEndAllowThreads(__tstate);
29298 if (PyErr_Occurred()) SWIG_fail;
29299 }
29300 resultobj = SWIG_Py_Void();
29301 return resultobj;
29302 fail:
29303 return NULL;
29304 }
29305
29306
29307 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29308 PyObject *resultobj = 0;
29309 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29310 int arg2 ;
29311 int arg3 ;
29312 int arg4 ;
29313 void *argp1 = 0 ;
29314 int res1 = 0 ;
29315 int val2 ;
29316 int ecode2 = 0 ;
29317 int val3 ;
29318 int ecode3 = 0 ;
29319 int val4 ;
29320 int ecode4 = 0 ;
29321 PyObject * obj0 = 0 ;
29322 PyObject * obj1 = 0 ;
29323 PyObject * obj2 = 0 ;
29324 PyObject * obj3 = 0 ;
29325 char * kwnames[] = {
29326 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29327 };
29328
29329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29331 if (!SWIG_IsOK(res1)) {
29332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29333 }
29334 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29335 ecode2 = SWIG_AsVal_int(obj1, &val2);
29336 if (!SWIG_IsOK(ecode2)) {
29337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29338 }
29339 arg2 = static_cast< int >(val2);
29340 ecode3 = SWIG_AsVal_int(obj2, &val3);
29341 if (!SWIG_IsOK(ecode3)) {
29342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29343 }
29344 arg3 = static_cast< int >(val3);
29345 ecode4 = SWIG_AsVal_int(obj3, &val4);
29346 if (!SWIG_IsOK(ecode4)) {
29347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29348 }
29349 arg4 = static_cast< int >(val4);
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 (arg1)->Set(arg2,arg3,arg4);
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_Py_Void();
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxString *arg1 = 0 ;
29366 wxAcceleratorEntry *result = 0 ;
29367 bool temp1 = false ;
29368 PyObject * obj0 = 0 ;
29369 char * kwnames[] = {
29370 (char *) "str", NULL
29371 };
29372
29373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29374 {
29375 arg1 = wxString_in_helper(obj0);
29376 if (arg1 == NULL) SWIG_fail;
29377 temp1 = true;
29378 }
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29386 {
29387 if (temp1)
29388 delete arg1;
29389 }
29390 return resultobj;
29391 fail:
29392 {
29393 if (temp1)
29394 delete arg1;
29395 }
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29403 int result;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 PyObject *swig_obj[1] ;
29407
29408 if (!args) SWIG_fail;
29409 swig_obj[0] = args;
29410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29413 }
29414 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (int)(arg1)->GetFlags();
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 resultobj = SWIG_From_int(static_cast< int >(result));
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29429 PyObject *resultobj = 0;
29430 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29431 int result;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 PyObject *swig_obj[1] ;
29435
29436 if (!args) SWIG_fail;
29437 swig_obj[0] = args;
29438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29439 if (!SWIG_IsOK(res1)) {
29440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29441 }
29442 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29443 {
29444 PyThreadState* __tstate = wxPyBeginAllowThreads();
29445 result = (int)(arg1)->GetKeyCode();
29446 wxPyEndAllowThreads(__tstate);
29447 if (PyErr_Occurred()) SWIG_fail;
29448 }
29449 resultobj = SWIG_From_int(static_cast< int >(result));
29450 return resultobj;
29451 fail:
29452 return NULL;
29453 }
29454
29455
29456 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29457 PyObject *resultobj = 0;
29458 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29459 int result;
29460 void *argp1 = 0 ;
29461 int res1 = 0 ;
29462 PyObject *swig_obj[1] ;
29463
29464 if (!args) SWIG_fail;
29465 swig_obj[0] = args;
29466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29467 if (!SWIG_IsOK(res1)) {
29468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29469 }
29470 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 result = (int)(arg1)->GetCommand();
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 resultobj = SWIG_From_int(static_cast< int >(result));
29478 return resultobj;
29479 fail:
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29485 PyObject *resultobj = 0;
29486 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29487 bool result;
29488 void *argp1 = 0 ;
29489 int res1 = 0 ;
29490 PyObject *swig_obj[1] ;
29491
29492 if (!args) SWIG_fail;
29493 swig_obj[0] = args;
29494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29495 if (!SWIG_IsOK(res1)) {
29496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29497 }
29498 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29499 {
29500 PyThreadState* __tstate = wxPyBeginAllowThreads();
29501 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 {
29506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29507 }
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29515 PyObject *resultobj = 0;
29516 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29517 wxString result;
29518 void *argp1 = 0 ;
29519 int res1 = 0 ;
29520 PyObject *swig_obj[1] ;
29521
29522 if (!args) SWIG_fail;
29523 swig_obj[0] = args;
29524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29525 if (!SWIG_IsOK(res1)) {
29526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29527 }
29528 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29529 {
29530 PyThreadState* __tstate = wxPyBeginAllowThreads();
29531 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29532 wxPyEndAllowThreads(__tstate);
29533 if (PyErr_Occurred()) SWIG_fail;
29534 }
29535 {
29536 #if wxUSE_UNICODE
29537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29538 #else
29539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29540 #endif
29541 }
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj = 0;
29550 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29551 wxString *arg2 = 0 ;
29552 bool result;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 bool temp2 = false ;
29556 PyObject * obj0 = 0 ;
29557 PyObject * obj1 = 0 ;
29558 char * kwnames[] = {
29559 (char *) "self",(char *) "str", NULL
29560 };
29561
29562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29564 if (!SWIG_IsOK(res1)) {
29565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29566 }
29567 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29568 {
29569 arg2 = wxString_in_helper(obj1);
29570 if (arg2 == NULL) SWIG_fail;
29571 temp2 = true;
29572 }
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 {
29580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29581 }
29582 {
29583 if (temp2)
29584 delete arg2;
29585 }
29586 return resultobj;
29587 fail:
29588 {
29589 if (temp2)
29590 delete arg2;
29591 }
29592 return NULL;
29593 }
29594
29595
29596 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29597 PyObject *obj;
29598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29599 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29600 return SWIG_Py_Void();
29601 }
29602
29603 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29604 return SWIG_Python_InitShadowInstance(args);
29605 }
29606
29607 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj = 0;
29609 int arg1 ;
29610 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29611 wxAcceleratorTable *result = 0 ;
29612 PyObject * obj0 = 0 ;
29613 char * kwnames[] = {
29614 (char *) "n", NULL
29615 };
29616
29617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29618 {
29619 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29620 if (arg2) arg1 = PyList_Size(obj0);
29621 else arg1 = 0;
29622 }
29623 {
29624 PyThreadState* __tstate = wxPyBeginAllowThreads();
29625 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29637 PyObject *resultobj = 0;
29638 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 PyObject *swig_obj[1] ;
29642
29643 if (!args) SWIG_fail;
29644 swig_obj[0] = args;
29645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29648 }
29649 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 delete arg1;
29653
29654 wxPyEndAllowThreads(__tstate);
29655 if (PyErr_Occurred()) SWIG_fail;
29656 }
29657 resultobj = SWIG_Py_Void();
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29665 PyObject *resultobj = 0;
29666 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29667 bool result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 PyObject *swig_obj[1] ;
29671
29672 if (!args) SWIG_fail;
29673 swig_obj[0] = args;
29674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29695 PyObject *obj;
29696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29697 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29698 return SWIG_Py_Void();
29699 }
29700
29701 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29702 return SWIG_Python_InitShadowInstance(args);
29703 }
29704
29705 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29706 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29707 return 1;
29708 }
29709
29710
29711 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29712 PyObject *pyobj = 0;
29713
29714 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29715 return pyobj;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29720 PyObject *resultobj = 0;
29721 wxString *arg1 = 0 ;
29722 wxAcceleratorEntry *result = 0 ;
29723 bool temp1 = false ;
29724 PyObject * obj0 = 0 ;
29725 char * kwnames[] = {
29726 (char *) "label", NULL
29727 };
29728
29729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29730 {
29731 arg1 = wxString_in_helper(obj0);
29732 if (arg1 == NULL) SWIG_fail;
29733 temp1 = true;
29734 }
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29742 {
29743 if (temp1)
29744 delete arg1;
29745 }
29746 return resultobj;
29747 fail:
29748 {
29749 if (temp1)
29750 delete arg1;
29751 }
29752 return NULL;
29753 }
29754
29755
29756 SWIGINTERN int PanelNameStr_set(PyObject *) {
29757 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29758 return 1;
29759 }
29760
29761
29762 SWIGINTERN PyObject *PanelNameStr_get(void) {
29763 PyObject *pyobj = 0;
29764
29765 {
29766 #if wxUSE_UNICODE
29767 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29768 #else
29769 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29770 #endif
29771 }
29772 return pyobj;
29773 }
29774
29775
29776 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29777 PyObject *resultobj = 0;
29778 wxVisualAttributes *result = 0 ;
29779
29780 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29781 {
29782 PyThreadState* __tstate = wxPyBeginAllowThreads();
29783 result = (wxVisualAttributes *)new_wxVisualAttributes();
29784 wxPyEndAllowThreads(__tstate);
29785 if (PyErr_Occurred()) SWIG_fail;
29786 }
29787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29795 PyObject *resultobj = 0;
29796 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29797 void *argp1 = 0 ;
29798 int res1 = 0 ;
29799 PyObject *swig_obj[1] ;
29800
29801 if (!args) SWIG_fail;
29802 swig_obj[0] = args;
29803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29806 }
29807 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29808 {
29809 PyThreadState* __tstate = wxPyBeginAllowThreads();
29810 delete_wxVisualAttributes(arg1);
29811
29812 wxPyEndAllowThreads(__tstate);
29813 if (PyErr_Occurred()) SWIG_fail;
29814 }
29815 resultobj = SWIG_Py_Void();
29816 return resultobj;
29817 fail:
29818 return NULL;
29819 }
29820
29821
29822 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29823 PyObject *resultobj = 0;
29824 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29825 wxFont *arg2 = (wxFont *) 0 ;
29826 void *argp1 = 0 ;
29827 int res1 = 0 ;
29828 void *argp2 = 0 ;
29829 int res2 = 0 ;
29830 PyObject *swig_obj[2] ;
29831
29832 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29834 if (!SWIG_IsOK(res1)) {
29835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29836 }
29837 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29838 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29839 if (!SWIG_IsOK(res2)) {
29840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29841 }
29842 arg2 = reinterpret_cast< wxFont * >(argp2);
29843 if (arg1) (arg1)->font = *arg2;
29844
29845 resultobj = SWIG_Py_Void();
29846 return resultobj;
29847 fail:
29848 return NULL;
29849 }
29850
29851
29852 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29853 PyObject *resultobj = 0;
29854 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29855 wxFont *result = 0 ;
29856 void *argp1 = 0 ;
29857 int res1 = 0 ;
29858 PyObject *swig_obj[1] ;
29859
29860 if (!args) SWIG_fail;
29861 swig_obj[0] = args;
29862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29863 if (!SWIG_IsOK(res1)) {
29864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29865 }
29866 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29867 result = (wxFont *)& ((arg1)->font);
29868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29876 PyObject *resultobj = 0;
29877 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29878 wxColour *arg2 = (wxColour *) 0 ;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 PyObject *swig_obj[2] ;
29884
29885 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29887 if (!SWIG_IsOK(res1)) {
29888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29889 }
29890 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29891 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29892 if (!SWIG_IsOK(res2)) {
29893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29894 }
29895 arg2 = reinterpret_cast< wxColour * >(argp2);
29896 if (arg1) (arg1)->colFg = *arg2;
29897
29898 resultobj = SWIG_Py_Void();
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29906 PyObject *resultobj = 0;
29907 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29908 wxColour *result = 0 ;
29909 void *argp1 = 0 ;
29910 int res1 = 0 ;
29911 PyObject *swig_obj[1] ;
29912
29913 if (!args) SWIG_fail;
29914 swig_obj[0] = args;
29915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29916 if (!SWIG_IsOK(res1)) {
29917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29918 }
29919 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29920 result = (wxColour *)& ((arg1)->colFg);
29921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29929 PyObject *resultobj = 0;
29930 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29931 wxColour *arg2 = (wxColour *) 0 ;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 void *argp2 = 0 ;
29935 int res2 = 0 ;
29936 PyObject *swig_obj[2] ;
29937
29938 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29940 if (!SWIG_IsOK(res1)) {
29941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29942 }
29943 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29944 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29945 if (!SWIG_IsOK(res2)) {
29946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29947 }
29948 arg2 = reinterpret_cast< wxColour * >(argp2);
29949 if (arg1) (arg1)->colBg = *arg2;
29950
29951 resultobj = SWIG_Py_Void();
29952 return resultobj;
29953 fail:
29954 return NULL;
29955 }
29956
29957
29958 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29959 PyObject *resultobj = 0;
29960 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29961 wxColour *result = 0 ;
29962 void *argp1 = 0 ;
29963 int res1 = 0 ;
29964 PyObject *swig_obj[1] ;
29965
29966 if (!args) SWIG_fail;
29967 swig_obj[0] = args;
29968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29969 if (!SWIG_IsOK(res1)) {
29970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29971 }
29972 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29973 result = (wxColour *)& ((arg1)->colBg);
29974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29982 PyObject *obj;
29983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29984 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29985 return SWIG_Py_Void();
29986 }
29987
29988 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29989 return SWIG_Python_InitShadowInstance(args);
29990 }
29991
29992 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29993 PyObject *resultobj = 0;
29994 wxWindow *arg1 = (wxWindow *) 0 ;
29995 int arg2 = (int) (int)-1 ;
29996 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29997 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29998 wxSize const &arg4_defvalue = wxDefaultSize ;
29999 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30000 long arg5 = (long) 0 ;
30001 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30002 wxString *arg6 = (wxString *) &arg6_defvalue ;
30003 wxWindow *result = 0 ;
30004 void *argp1 = 0 ;
30005 int res1 = 0 ;
30006 int val2 ;
30007 int ecode2 = 0 ;
30008 wxPoint temp3 ;
30009 wxSize temp4 ;
30010 long val5 ;
30011 int ecode5 = 0 ;
30012 bool temp6 = false ;
30013 PyObject * obj0 = 0 ;
30014 PyObject * obj1 = 0 ;
30015 PyObject * obj2 = 0 ;
30016 PyObject * obj3 = 0 ;
30017 PyObject * obj4 = 0 ;
30018 PyObject * obj5 = 0 ;
30019 char * kwnames[] = {
30020 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30021 };
30022
30023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30025 if (!SWIG_IsOK(res1)) {
30026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30027 }
30028 arg1 = reinterpret_cast< wxWindow * >(argp1);
30029 if (obj1) {
30030 ecode2 = SWIG_AsVal_int(obj1, &val2);
30031 if (!SWIG_IsOK(ecode2)) {
30032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30033 }
30034 arg2 = static_cast< int >(val2);
30035 }
30036 if (obj2) {
30037 {
30038 arg3 = &temp3;
30039 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30040 }
30041 }
30042 if (obj3) {
30043 {
30044 arg4 = &temp4;
30045 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30046 }
30047 }
30048 if (obj4) {
30049 ecode5 = SWIG_AsVal_long(obj4, &val5);
30050 if (!SWIG_IsOK(ecode5)) {
30051 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30052 }
30053 arg5 = static_cast< long >(val5);
30054 }
30055 if (obj5) {
30056 {
30057 arg6 = wxString_in_helper(obj5);
30058 if (arg6 == NULL) SWIG_fail;
30059 temp6 = true;
30060 }
30061 }
30062 {
30063 if (!wxPyCheckForApp()) SWIG_fail;
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30070 {
30071 if (temp6)
30072 delete arg6;
30073 }
30074 return resultobj;
30075 fail:
30076 {
30077 if (temp6)
30078 delete arg6;
30079 }
30080 return NULL;
30081 }
30082
30083
30084 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30085 PyObject *resultobj = 0;
30086 wxWindow *result = 0 ;
30087
30088 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30089 {
30090 if (!wxPyCheckForApp()) SWIG_fail;
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (wxWindow *)new wxWindow();
30093 wxPyEndAllowThreads(__tstate);
30094 if (PyErr_Occurred()) SWIG_fail;
30095 }
30096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30104 PyObject *resultobj = 0;
30105 wxWindow *arg1 = (wxWindow *) 0 ;
30106 wxWindow *arg2 = (wxWindow *) 0 ;
30107 int arg3 = (int) (int)-1 ;
30108 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30109 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30110 wxSize const &arg5_defvalue = wxDefaultSize ;
30111 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30112 long arg6 = (long) 0 ;
30113 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30114 wxString *arg7 = (wxString *) &arg7_defvalue ;
30115 bool result;
30116 void *argp1 = 0 ;
30117 int res1 = 0 ;
30118 void *argp2 = 0 ;
30119 int res2 = 0 ;
30120 int val3 ;
30121 int ecode3 = 0 ;
30122 wxPoint temp4 ;
30123 wxSize temp5 ;
30124 long val6 ;
30125 int ecode6 = 0 ;
30126 bool temp7 = false ;
30127 PyObject * obj0 = 0 ;
30128 PyObject * obj1 = 0 ;
30129 PyObject * obj2 = 0 ;
30130 PyObject * obj3 = 0 ;
30131 PyObject * obj4 = 0 ;
30132 PyObject * obj5 = 0 ;
30133 PyObject * obj6 = 0 ;
30134 char * kwnames[] = {
30135 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30136 };
30137
30138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30140 if (!SWIG_IsOK(res1)) {
30141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30142 }
30143 arg1 = reinterpret_cast< wxWindow * >(argp1);
30144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30145 if (!SWIG_IsOK(res2)) {
30146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30147 }
30148 arg2 = reinterpret_cast< wxWindow * >(argp2);
30149 if (obj2) {
30150 ecode3 = SWIG_AsVal_int(obj2, &val3);
30151 if (!SWIG_IsOK(ecode3)) {
30152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30153 }
30154 arg3 = static_cast< int >(val3);
30155 }
30156 if (obj3) {
30157 {
30158 arg4 = &temp4;
30159 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30160 }
30161 }
30162 if (obj4) {
30163 {
30164 arg5 = &temp5;
30165 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30166 }
30167 }
30168 if (obj5) {
30169 ecode6 = SWIG_AsVal_long(obj5, &val6);
30170 if (!SWIG_IsOK(ecode6)) {
30171 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30172 }
30173 arg6 = static_cast< long >(val6);
30174 }
30175 if (obj6) {
30176 {
30177 arg7 = wxString_in_helper(obj6);
30178 if (arg7 == NULL) SWIG_fail;
30179 temp7 = true;
30180 }
30181 }
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 {
30189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30190 }
30191 {
30192 if (temp7)
30193 delete arg7;
30194 }
30195 return resultobj;
30196 fail:
30197 {
30198 if (temp7)
30199 delete arg7;
30200 }
30201 return NULL;
30202 }
30203
30204
30205 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj = 0;
30207 wxWindow *arg1 = (wxWindow *) 0 ;
30208 bool arg2 = (bool) false ;
30209 bool result;
30210 void *argp1 = 0 ;
30211 int res1 = 0 ;
30212 bool val2 ;
30213 int ecode2 = 0 ;
30214 PyObject * obj0 = 0 ;
30215 PyObject * obj1 = 0 ;
30216 char * kwnames[] = {
30217 (char *) "self",(char *) "force", NULL
30218 };
30219
30220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30222 if (!SWIG_IsOK(res1)) {
30223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30224 }
30225 arg1 = reinterpret_cast< wxWindow * >(argp1);
30226 if (obj1) {
30227 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30228 if (!SWIG_IsOK(ecode2)) {
30229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30230 }
30231 arg2 = static_cast< bool >(val2);
30232 }
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (bool)(arg1)->Close(arg2);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 {
30240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30241 }
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30249 PyObject *resultobj = 0;
30250 wxWindow *arg1 = (wxWindow *) 0 ;
30251 bool result;
30252 void *argp1 = 0 ;
30253 int res1 = 0 ;
30254 PyObject *swig_obj[1] ;
30255
30256 if (!args) SWIG_fail;
30257 swig_obj[0] = args;
30258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30259 if (!SWIG_IsOK(res1)) {
30260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30261 }
30262 arg1 = reinterpret_cast< wxWindow * >(argp1);
30263 {
30264 PyThreadState* __tstate = wxPyBeginAllowThreads();
30265 result = (bool)(arg1)->Destroy();
30266 wxPyEndAllowThreads(__tstate);
30267 if (PyErr_Occurred()) SWIG_fail;
30268 }
30269 {
30270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30271 }
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30279 PyObject *resultobj = 0;
30280 wxWindow *arg1 = (wxWindow *) 0 ;
30281 bool result;
30282 void *argp1 = 0 ;
30283 int res1 = 0 ;
30284 PyObject *swig_obj[1] ;
30285
30286 if (!args) SWIG_fail;
30287 swig_obj[0] = args;
30288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30289 if (!SWIG_IsOK(res1)) {
30290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30291 }
30292 arg1 = reinterpret_cast< wxWindow * >(argp1);
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 result = (bool)(arg1)->DestroyChildren();
30296 wxPyEndAllowThreads(__tstate);
30297 if (PyErr_Occurred()) SWIG_fail;
30298 }
30299 {
30300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30301 }
30302 return resultobj;
30303 fail:
30304 return NULL;
30305 }
30306
30307
30308 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30309 PyObject *resultobj = 0;
30310 wxWindow *arg1 = (wxWindow *) 0 ;
30311 bool result;
30312 void *argp1 = 0 ;
30313 int res1 = 0 ;
30314 PyObject *swig_obj[1] ;
30315
30316 if (!args) SWIG_fail;
30317 swig_obj[0] = args;
30318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30319 if (!SWIG_IsOK(res1)) {
30320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30321 }
30322 arg1 = reinterpret_cast< wxWindow * >(argp1);
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 {
30330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj = 0;
30340 wxWindow *arg1 = (wxWindow *) 0 ;
30341 wxString *arg2 = 0 ;
30342 void *argp1 = 0 ;
30343 int res1 = 0 ;
30344 bool temp2 = false ;
30345 PyObject * obj0 = 0 ;
30346 PyObject * obj1 = 0 ;
30347 char * kwnames[] = {
30348 (char *) "self",(char *) "label", NULL
30349 };
30350
30351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30353 if (!SWIG_IsOK(res1)) {
30354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30355 }
30356 arg1 = reinterpret_cast< wxWindow * >(argp1);
30357 {
30358 arg2 = wxString_in_helper(obj1);
30359 if (arg2 == NULL) SWIG_fail;
30360 temp2 = true;
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 (arg1)->SetLabel((wxString const &)*arg2);
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 resultobj = SWIG_Py_Void();
30369 {
30370 if (temp2)
30371 delete arg2;
30372 }
30373 return resultobj;
30374 fail:
30375 {
30376 if (temp2)
30377 delete arg2;
30378 }
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30384 PyObject *resultobj = 0;
30385 wxWindow *arg1 = (wxWindow *) 0 ;
30386 wxString result;
30387 void *argp1 = 0 ;
30388 int res1 = 0 ;
30389 PyObject *swig_obj[1] ;
30390
30391 if (!args) SWIG_fail;
30392 swig_obj[0] = args;
30393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30394 if (!SWIG_IsOK(res1)) {
30395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30396 }
30397 arg1 = reinterpret_cast< wxWindow * >(argp1);
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = ((wxWindow const *)arg1)->GetLabel();
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 {
30405 #if wxUSE_UNICODE
30406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30407 #else
30408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30409 #endif
30410 }
30411 return resultobj;
30412 fail:
30413 return NULL;
30414 }
30415
30416
30417 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30418 PyObject *resultobj = 0;
30419 wxWindow *arg1 = (wxWindow *) 0 ;
30420 wxString *arg2 = 0 ;
30421 void *argp1 = 0 ;
30422 int res1 = 0 ;
30423 bool temp2 = false ;
30424 PyObject * obj0 = 0 ;
30425 PyObject * obj1 = 0 ;
30426 char * kwnames[] = {
30427 (char *) "self",(char *) "name", NULL
30428 };
30429
30430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30434 }
30435 arg1 = reinterpret_cast< wxWindow * >(argp1);
30436 {
30437 arg2 = wxString_in_helper(obj1);
30438 if (arg2 == NULL) SWIG_fail;
30439 temp2 = true;
30440 }
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 (arg1)->SetName((wxString const &)*arg2);
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_Py_Void();
30448 {
30449 if (temp2)
30450 delete arg2;
30451 }
30452 return resultobj;
30453 fail:
30454 {
30455 if (temp2)
30456 delete arg2;
30457 }
30458 return NULL;
30459 }
30460
30461
30462 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30463 PyObject *resultobj = 0;
30464 wxWindow *arg1 = (wxWindow *) 0 ;
30465 wxString result;
30466 void *argp1 = 0 ;
30467 int res1 = 0 ;
30468 PyObject *swig_obj[1] ;
30469
30470 if (!args) SWIG_fail;
30471 swig_obj[0] = args;
30472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30473 if (!SWIG_IsOK(res1)) {
30474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30475 }
30476 arg1 = reinterpret_cast< wxWindow * >(argp1);
30477 {
30478 PyThreadState* __tstate = wxPyBeginAllowThreads();
30479 result = ((wxWindow const *)arg1)->GetName();
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 #if wxUSE_UNICODE
30485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30486 #else
30487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30488 #endif
30489 }
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj = 0;
30498 wxWindow *arg1 = (wxWindow *) 0 ;
30499 wxWindowVariant arg2 ;
30500 void *argp1 = 0 ;
30501 int res1 = 0 ;
30502 int val2 ;
30503 int ecode2 = 0 ;
30504 PyObject * obj0 = 0 ;
30505 PyObject * obj1 = 0 ;
30506 char * kwnames[] = {
30507 (char *) "self",(char *) "variant", NULL
30508 };
30509
30510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30512 if (!SWIG_IsOK(res1)) {
30513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30514 }
30515 arg1 = reinterpret_cast< wxWindow * >(argp1);
30516 ecode2 = SWIG_AsVal_int(obj1, &val2);
30517 if (!SWIG_IsOK(ecode2)) {
30518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30519 }
30520 arg2 = static_cast< wxWindowVariant >(val2);
30521 {
30522 PyThreadState* __tstate = wxPyBeginAllowThreads();
30523 (arg1)->SetWindowVariant(arg2);
30524 wxPyEndAllowThreads(__tstate);
30525 if (PyErr_Occurred()) SWIG_fail;
30526 }
30527 resultobj = SWIG_Py_Void();
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30535 PyObject *resultobj = 0;
30536 wxWindow *arg1 = (wxWindow *) 0 ;
30537 wxWindowVariant result;
30538 void *argp1 = 0 ;
30539 int res1 = 0 ;
30540 PyObject *swig_obj[1] ;
30541
30542 if (!args) SWIG_fail;
30543 swig_obj[0] = args;
30544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30547 }
30548 arg1 = reinterpret_cast< wxWindow * >(argp1);
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30552 wxPyEndAllowThreads(__tstate);
30553 if (PyErr_Occurred()) SWIG_fail;
30554 }
30555 resultobj = SWIG_From_int(static_cast< int >(result));
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30563 PyObject *resultobj = 0;
30564 wxWindow *arg1 = (wxWindow *) 0 ;
30565 int arg2 ;
30566 void *argp1 = 0 ;
30567 int res1 = 0 ;
30568 int val2 ;
30569 int ecode2 = 0 ;
30570 PyObject * obj0 = 0 ;
30571 PyObject * obj1 = 0 ;
30572 char * kwnames[] = {
30573 (char *) "self",(char *) "winid", NULL
30574 };
30575
30576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30578 if (!SWIG_IsOK(res1)) {
30579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30580 }
30581 arg1 = reinterpret_cast< wxWindow * >(argp1);
30582 ecode2 = SWIG_AsVal_int(obj1, &val2);
30583 if (!SWIG_IsOK(ecode2)) {
30584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30585 }
30586 arg2 = static_cast< int >(val2);
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 (arg1)->SetId(arg2);
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 resultobj = SWIG_Py_Void();
30594 return resultobj;
30595 fail:
30596 return NULL;
30597 }
30598
30599
30600 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30601 PyObject *resultobj = 0;
30602 wxWindow *arg1 = (wxWindow *) 0 ;
30603 int result;
30604 void *argp1 = 0 ;
30605 int res1 = 0 ;
30606 PyObject *swig_obj[1] ;
30607
30608 if (!args) SWIG_fail;
30609 swig_obj[0] = args;
30610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 {
30616 PyThreadState* __tstate = wxPyBeginAllowThreads();
30617 result = (int)((wxWindow const *)arg1)->GetId();
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_From_int(static_cast< int >(result));
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30629 PyObject *resultobj = 0;
30630 int result;
30631
30632 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30633 {
30634 PyThreadState* __tstate = wxPyBeginAllowThreads();
30635 result = (int)wxWindow::NewControlId();
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_From_int(static_cast< int >(result));
30640 return resultobj;
30641 fail:
30642 return NULL;
30643 }
30644
30645
30646 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30647 PyObject *resultobj = 0;
30648 int arg1 ;
30649 int result;
30650 int val1 ;
30651 int ecode1 = 0 ;
30652 PyObject * obj0 = 0 ;
30653 char * kwnames[] = {
30654 (char *) "winid", NULL
30655 };
30656
30657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30658 ecode1 = SWIG_AsVal_int(obj0, &val1);
30659 if (!SWIG_IsOK(ecode1)) {
30660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30661 }
30662 arg1 = static_cast< int >(val1);
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (int)wxWindow::NextControlId(arg1);
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_From_int(static_cast< int >(result));
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 int arg1 ;
30679 int result;
30680 int val1 ;
30681 int ecode1 = 0 ;
30682 PyObject * obj0 = 0 ;
30683 char * kwnames[] = {
30684 (char *) "winid", NULL
30685 };
30686
30687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30688 ecode1 = SWIG_AsVal_int(obj0, &val1);
30689 if (!SWIG_IsOK(ecode1)) {
30690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30691 }
30692 arg1 = static_cast< int >(val1);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 result = (int)wxWindow::PrevControlId(arg1);
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_From_int(static_cast< int >(result));
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30707 PyObject *resultobj = 0;
30708 wxWindow *arg1 = (wxWindow *) 0 ;
30709 wxLayoutDirection result;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 PyObject *swig_obj[1] ;
30713
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxWindow * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = ((wxWindow const *)arg1)->GetLayoutDirection();
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30735 PyObject *resultobj = 0;
30736 wxWindow *arg1 = (wxWindow *) 0 ;
30737 wxLayoutDirection arg2 ;
30738 void *argp1 = 0 ;
30739 int res1 = 0 ;
30740 void *argp2 ;
30741 int res2 = 0 ;
30742 PyObject * obj0 = 0 ;
30743 PyObject * obj1 = 0 ;
30744 char * kwnames[] = {
30745 (char *) "self",(char *) "dir", NULL
30746 };
30747
30748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30750 if (!SWIG_IsOK(res1)) {
30751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30752 }
30753 arg1 = reinterpret_cast< wxWindow * >(argp1);
30754 {
30755 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxLayoutDirection, 0 | 0);
30756 if (!SWIG_IsOK(res2)) {
30757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30758 }
30759 if (!argp2) {
30760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30761 } else {
30762 wxLayoutDirection * temp = reinterpret_cast< wxLayoutDirection * >(argp2);
30763 arg2 = *temp;
30764 if (SWIG_IsNewObj(res2)) delete temp;
30765 }
30766 }
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 (arg1)->SetLayoutDirection(arg2);
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_Py_Void();
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj = 0;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 int arg2 ;
30784 int arg3 ;
30785 int arg4 ;
30786 int result;
30787 void *argp1 = 0 ;
30788 int res1 = 0 ;
30789 int val2 ;
30790 int ecode2 = 0 ;
30791 int val3 ;
30792 int ecode3 = 0 ;
30793 int val4 ;
30794 int ecode4 = 0 ;
30795 PyObject * obj0 = 0 ;
30796 PyObject * obj1 = 0 ;
30797 PyObject * obj2 = 0 ;
30798 PyObject * obj3 = 0 ;
30799 char * kwnames[] = {
30800 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30801 };
30802
30803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30805 if (!SWIG_IsOK(res1)) {
30806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30807 }
30808 arg1 = reinterpret_cast< wxWindow * >(argp1);
30809 ecode2 = SWIG_AsVal_int(obj1, &val2);
30810 if (!SWIG_IsOK(ecode2)) {
30811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30812 }
30813 arg2 = static_cast< int >(val2);
30814 ecode3 = SWIG_AsVal_int(obj2, &val3);
30815 if (!SWIG_IsOK(ecode3)) {
30816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30817 }
30818 arg3 = static_cast< int >(val3);
30819 ecode4 = SWIG_AsVal_int(obj3, &val4);
30820 if (!SWIG_IsOK(ecode4)) {
30821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30822 }
30823 arg4 = static_cast< int >(val4);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_From_int(static_cast< int >(result));
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30838 PyObject *resultobj = 0;
30839 wxWindow *arg1 = (wxWindow *) 0 ;
30840 wxSize *arg2 = 0 ;
30841 void *argp1 = 0 ;
30842 int res1 = 0 ;
30843 wxSize temp2 ;
30844 PyObject * obj0 = 0 ;
30845 PyObject * obj1 = 0 ;
30846 char * kwnames[] = {
30847 (char *) "self",(char *) "size", NULL
30848 };
30849
30850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30852 if (!SWIG_IsOK(res1)) {
30853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30854 }
30855 arg1 = reinterpret_cast< wxWindow * >(argp1);
30856 {
30857 arg2 = &temp2;
30858 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30859 }
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 (arg1)->SetSize((wxSize const &)*arg2);
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 resultobj = SWIG_Py_Void();
30867 return resultobj;
30868 fail:
30869 return NULL;
30870 }
30871
30872
30873 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30874 PyObject *resultobj = 0;
30875 wxWindow *arg1 = (wxWindow *) 0 ;
30876 int arg2 ;
30877 int arg3 ;
30878 int arg4 ;
30879 int arg5 ;
30880 int arg6 = (int) wxSIZE_AUTO ;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 int val2 ;
30884 int ecode2 = 0 ;
30885 int val3 ;
30886 int ecode3 = 0 ;
30887 int val4 ;
30888 int ecode4 = 0 ;
30889 int val5 ;
30890 int ecode5 = 0 ;
30891 int val6 ;
30892 int ecode6 = 0 ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 PyObject * obj2 = 0 ;
30896 PyObject * obj3 = 0 ;
30897 PyObject * obj4 = 0 ;
30898 PyObject * obj5 = 0 ;
30899 char * kwnames[] = {
30900 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30901 };
30902
30903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 ecode2 = SWIG_AsVal_int(obj1, &val2);
30910 if (!SWIG_IsOK(ecode2)) {
30911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30912 }
30913 arg2 = static_cast< int >(val2);
30914 ecode3 = SWIG_AsVal_int(obj2, &val3);
30915 if (!SWIG_IsOK(ecode3)) {
30916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30917 }
30918 arg3 = static_cast< int >(val3);
30919 ecode4 = SWIG_AsVal_int(obj3, &val4);
30920 if (!SWIG_IsOK(ecode4)) {
30921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30922 }
30923 arg4 = static_cast< int >(val4);
30924 ecode5 = SWIG_AsVal_int(obj4, &val5);
30925 if (!SWIG_IsOK(ecode5)) {
30926 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30927 }
30928 arg5 = static_cast< int >(val5);
30929 if (obj5) {
30930 ecode6 = SWIG_AsVal_int(obj5, &val6);
30931 if (!SWIG_IsOK(ecode6)) {
30932 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30933 }
30934 arg6 = static_cast< int >(val6);
30935 }
30936 {
30937 PyThreadState* __tstate = wxPyBeginAllowThreads();
30938 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30939 wxPyEndAllowThreads(__tstate);
30940 if (PyErr_Occurred()) SWIG_fail;
30941 }
30942 resultobj = SWIG_Py_Void();
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxWindow *arg1 = (wxWindow *) 0 ;
30952 wxRect *arg2 = 0 ;
30953 int arg3 = (int) wxSIZE_AUTO ;
30954 void *argp1 = 0 ;
30955 int res1 = 0 ;
30956 wxRect temp2 ;
30957 int val3 ;
30958 int ecode3 = 0 ;
30959 PyObject * obj0 = 0 ;
30960 PyObject * obj1 = 0 ;
30961 PyObject * obj2 = 0 ;
30962 char * kwnames[] = {
30963 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30964 };
30965
30966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 arg2 = &temp2;
30974 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30975 }
30976 if (obj2) {
30977 ecode3 = SWIG_AsVal_int(obj2, &val3);
30978 if (!SWIG_IsOK(ecode3)) {
30979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30980 }
30981 arg3 = static_cast< int >(val3);
30982 }
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 resultobj = SWIG_Py_Void();
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj = 0;
30998 wxWindow *arg1 = (wxWindow *) 0 ;
30999 int arg2 ;
31000 int arg3 ;
31001 void *argp1 = 0 ;
31002 int res1 = 0 ;
31003 int val2 ;
31004 int ecode2 = 0 ;
31005 int val3 ;
31006 int ecode3 = 0 ;
31007 PyObject * obj0 = 0 ;
31008 PyObject * obj1 = 0 ;
31009 PyObject * obj2 = 0 ;
31010 char * kwnames[] = {
31011 (char *) "self",(char *) "width",(char *) "height", NULL
31012 };
31013
31014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31018 }
31019 arg1 = reinterpret_cast< wxWindow * >(argp1);
31020 ecode2 = SWIG_AsVal_int(obj1, &val2);
31021 if (!SWIG_IsOK(ecode2)) {
31022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31023 }
31024 arg2 = static_cast< int >(val2);
31025 ecode3 = SWIG_AsVal_int(obj2, &val3);
31026 if (!SWIG_IsOK(ecode3)) {
31027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31028 }
31029 arg3 = static_cast< int >(val3);
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 (arg1)->SetSize(arg2,arg3);
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 resultobj = SWIG_Py_Void();
31037 return resultobj;
31038 fail:
31039 return NULL;
31040 }
31041
31042
31043 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31044 PyObject *resultobj = 0;
31045 wxWindow *arg1 = (wxWindow *) 0 ;
31046 wxPoint *arg2 = 0 ;
31047 int arg3 = (int) wxSIZE_USE_EXISTING ;
31048 void *argp1 = 0 ;
31049 int res1 = 0 ;
31050 wxPoint temp2 ;
31051 int val3 ;
31052 int ecode3 = 0 ;
31053 PyObject * obj0 = 0 ;
31054 PyObject * obj1 = 0 ;
31055 PyObject * obj2 = 0 ;
31056 char * kwnames[] = {
31057 (char *) "self",(char *) "pt",(char *) "flags", NULL
31058 };
31059
31060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31062 if (!SWIG_IsOK(res1)) {
31063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31064 }
31065 arg1 = reinterpret_cast< wxWindow * >(argp1);
31066 {
31067 arg2 = &temp2;
31068 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31069 }
31070 if (obj2) {
31071 ecode3 = SWIG_AsVal_int(obj2, &val3);
31072 if (!SWIG_IsOK(ecode3)) {
31073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31074 }
31075 arg3 = static_cast< int >(val3);
31076 }
31077 {
31078 PyThreadState* __tstate = wxPyBeginAllowThreads();
31079 (arg1)->Move((wxPoint const &)*arg2,arg3);
31080 wxPyEndAllowThreads(__tstate);
31081 if (PyErr_Occurred()) SWIG_fail;
31082 }
31083 resultobj = SWIG_Py_Void();
31084 return resultobj;
31085 fail:
31086 return NULL;
31087 }
31088
31089
31090 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31091 PyObject *resultobj = 0;
31092 wxWindow *arg1 = (wxWindow *) 0 ;
31093 int arg2 ;
31094 int arg3 ;
31095 int arg4 = (int) wxSIZE_USE_EXISTING ;
31096 void *argp1 = 0 ;
31097 int res1 = 0 ;
31098 int val2 ;
31099 int ecode2 = 0 ;
31100 int val3 ;
31101 int ecode3 = 0 ;
31102 int val4 ;
31103 int ecode4 = 0 ;
31104 PyObject * obj0 = 0 ;
31105 PyObject * obj1 = 0 ;
31106 PyObject * obj2 = 0 ;
31107 PyObject * obj3 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 ecode2 = SWIG_AsVal_int(obj1, &val2);
31119 if (!SWIG_IsOK(ecode2)) {
31120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31121 }
31122 arg2 = static_cast< int >(val2);
31123 ecode3 = SWIG_AsVal_int(obj2, &val3);
31124 if (!SWIG_IsOK(ecode3)) {
31125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31126 }
31127 arg3 = static_cast< int >(val3);
31128 if (obj3) {
31129 ecode4 = SWIG_AsVal_int(obj3, &val4);
31130 if (!SWIG_IsOK(ecode4)) {
31131 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31132 }
31133 arg4 = static_cast< int >(val4);
31134 }
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 (arg1)->Move(arg2,arg3,arg4);
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_Py_Void();
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxWindow *arg1 = (wxWindow *) 0 ;
31151 wxSize const &arg2_defvalue = wxDefaultSize ;
31152 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31153 void *argp1 = 0 ;
31154 int res1 = 0 ;
31155 wxSize temp2 ;
31156 PyObject * obj0 = 0 ;
31157 PyObject * obj1 = 0 ;
31158 char * kwnames[] = {
31159 (char *) "self",(char *) "size", NULL
31160 };
31161
31162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31164 if (!SWIG_IsOK(res1)) {
31165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31166 }
31167 arg1 = reinterpret_cast< wxWindow * >(argp1);
31168 if (obj1) {
31169 {
31170 arg2 = &temp2;
31171 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31172 }
31173 }
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 resultobj = SWIG_Py_Void();
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31188 PyObject *resultobj = 0;
31189 wxWindow *arg1 = (wxWindow *) 0 ;
31190 void *argp1 = 0 ;
31191 int res1 = 0 ;
31192 PyObject *swig_obj[1] ;
31193
31194 if (!args) SWIG_fail;
31195 swig_obj[0] = args;
31196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31197 if (!SWIG_IsOK(res1)) {
31198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31199 }
31200 arg1 = reinterpret_cast< wxWindow * >(argp1);
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 (arg1)->Raise();
31204 wxPyEndAllowThreads(__tstate);
31205 if (PyErr_Occurred()) SWIG_fail;
31206 }
31207 resultobj = SWIG_Py_Void();
31208 return resultobj;
31209 fail:
31210 return NULL;
31211 }
31212
31213
31214 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31215 PyObject *resultobj = 0;
31216 wxWindow *arg1 = (wxWindow *) 0 ;
31217 void *argp1 = 0 ;
31218 int res1 = 0 ;
31219 PyObject *swig_obj[1] ;
31220
31221 if (!args) SWIG_fail;
31222 swig_obj[0] = args;
31223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31224 if (!SWIG_IsOK(res1)) {
31225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31226 }
31227 arg1 = reinterpret_cast< wxWindow * >(argp1);
31228 {
31229 PyThreadState* __tstate = wxPyBeginAllowThreads();
31230 (arg1)->Lower();
31231 wxPyEndAllowThreads(__tstate);
31232 if (PyErr_Occurred()) SWIG_fail;
31233 }
31234 resultobj = SWIG_Py_Void();
31235 return resultobj;
31236 fail:
31237 return NULL;
31238 }
31239
31240
31241 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31242 PyObject *resultobj = 0;
31243 wxWindow *arg1 = (wxWindow *) 0 ;
31244 wxSize *arg2 = 0 ;
31245 void *argp1 = 0 ;
31246 int res1 = 0 ;
31247 wxSize temp2 ;
31248 PyObject * obj0 = 0 ;
31249 PyObject * obj1 = 0 ;
31250 char * kwnames[] = {
31251 (char *) "self",(char *) "size", NULL
31252 };
31253
31254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31256 if (!SWIG_IsOK(res1)) {
31257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31258 }
31259 arg1 = reinterpret_cast< wxWindow * >(argp1);
31260 {
31261 arg2 = &temp2;
31262 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31263 }
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 (arg1)->SetClientSize((wxSize const &)*arg2);
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_Py_Void();
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 wxWindow *arg1 = (wxWindow *) 0 ;
31280 int arg2 ;
31281 int arg3 ;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 int val2 ;
31285 int ecode2 = 0 ;
31286 int val3 ;
31287 int ecode3 = 0 ;
31288 PyObject * obj0 = 0 ;
31289 PyObject * obj1 = 0 ;
31290 PyObject * obj2 = 0 ;
31291 char * kwnames[] = {
31292 (char *) "self",(char *) "width",(char *) "height", NULL
31293 };
31294
31295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31297 if (!SWIG_IsOK(res1)) {
31298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31299 }
31300 arg1 = reinterpret_cast< wxWindow * >(argp1);
31301 ecode2 = SWIG_AsVal_int(obj1, &val2);
31302 if (!SWIG_IsOK(ecode2)) {
31303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31304 }
31305 arg2 = static_cast< int >(val2);
31306 ecode3 = SWIG_AsVal_int(obj2, &val3);
31307 if (!SWIG_IsOK(ecode3)) {
31308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31309 }
31310 arg3 = static_cast< int >(val3);
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 (arg1)->SetClientSize(arg2,arg3);
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 resultobj = SWIG_Py_Void();
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31325 PyObject *resultobj = 0;
31326 wxWindow *arg1 = (wxWindow *) 0 ;
31327 wxRect *arg2 = 0 ;
31328 void *argp1 = 0 ;
31329 int res1 = 0 ;
31330 wxRect temp2 ;
31331 PyObject * obj0 = 0 ;
31332 PyObject * obj1 = 0 ;
31333 char * kwnames[] = {
31334 (char *) "self",(char *) "rect", NULL
31335 };
31336
31337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31339 if (!SWIG_IsOK(res1)) {
31340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31341 }
31342 arg1 = reinterpret_cast< wxWindow * >(argp1);
31343 {
31344 arg2 = &temp2;
31345 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31346 }
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 (arg1)->SetClientSize((wxRect const &)*arg2);
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 resultobj = SWIG_Py_Void();
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31361 PyObject *resultobj = 0;
31362 wxWindow *arg1 = (wxWindow *) 0 ;
31363 wxPoint result;
31364 void *argp1 = 0 ;
31365 int res1 = 0 ;
31366 PyObject *swig_obj[1] ;
31367
31368 if (!args) SWIG_fail;
31369 swig_obj[0] = args;
31370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31371 if (!SWIG_IsOK(res1)) {
31372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31373 }
31374 arg1 = reinterpret_cast< wxWindow * >(argp1);
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 result = ((wxWindow const *)arg1)->GetPosition();
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31389 PyObject *resultobj = 0;
31390 wxWindow *arg1 = (wxWindow *) 0 ;
31391 int *arg2 = (int *) 0 ;
31392 int *arg3 = (int *) 0 ;
31393 void *argp1 = 0 ;
31394 int res1 = 0 ;
31395 int temp2 ;
31396 int res2 = SWIG_TMPOBJ ;
31397 int temp3 ;
31398 int res3 = SWIG_TMPOBJ ;
31399 PyObject *swig_obj[1] ;
31400
31401 arg2 = &temp2;
31402 arg3 = &temp3;
31403 if (!args) SWIG_fail;
31404 swig_obj[0] = args;
31405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31406 if (!SWIG_IsOK(res1)) {
31407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31408 }
31409 arg1 = reinterpret_cast< wxWindow * >(argp1);
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31413 wxPyEndAllowThreads(__tstate);
31414 if (PyErr_Occurred()) SWIG_fail;
31415 }
31416 resultobj = SWIG_Py_Void();
31417 if (SWIG_IsTmpObj(res2)) {
31418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31419 } else {
31420 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31422 }
31423 if (SWIG_IsTmpObj(res3)) {
31424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31425 } else {
31426 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31428 }
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *resultobj = 0;
31437 wxWindow *arg1 = (wxWindow *) 0 ;
31438 wxPoint result;
31439 void *argp1 = 0 ;
31440 int res1 = 0 ;
31441 PyObject *swig_obj[1] ;
31442
31443 if (!args) SWIG_fail;
31444 swig_obj[0] = args;
31445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31446 if (!SWIG_IsOK(res1)) {
31447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31448 }
31449 arg1 = reinterpret_cast< wxWindow * >(argp1);
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = ((wxWindow const *)arg1)->GetScreenPosition();
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31464 PyObject *resultobj = 0;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 int *arg2 = (int *) 0 ;
31467 int *arg3 = (int *) 0 ;
31468 void *argp1 = 0 ;
31469 int res1 = 0 ;
31470 int temp2 ;
31471 int res2 = SWIG_TMPOBJ ;
31472 int temp3 ;
31473 int res3 = SWIG_TMPOBJ ;
31474 PyObject *swig_obj[1] ;
31475
31476 arg2 = &temp2;
31477 arg3 = &temp3;
31478 if (!args) SWIG_fail;
31479 swig_obj[0] = args;
31480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31481 if (!SWIG_IsOK(res1)) {
31482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31483 }
31484 arg1 = reinterpret_cast< wxWindow * >(argp1);
31485 {
31486 PyThreadState* __tstate = wxPyBeginAllowThreads();
31487 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 resultobj = SWIG_Py_Void();
31492 if (SWIG_IsTmpObj(res2)) {
31493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31494 } else {
31495 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31497 }
31498 if (SWIG_IsTmpObj(res3)) {
31499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31500 } else {
31501 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31503 }
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31511 PyObject *resultobj = 0;
31512 wxWindow *arg1 = (wxWindow *) 0 ;
31513 wxRect result;
31514 void *argp1 = 0 ;
31515 int res1 = 0 ;
31516 PyObject *swig_obj[1] ;
31517
31518 if (!args) SWIG_fail;
31519 swig_obj[0] = args;
31520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31521 if (!SWIG_IsOK(res1)) {
31522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31523 }
31524 arg1 = reinterpret_cast< wxWindow * >(argp1);
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 result = ((wxWindow const *)arg1)->GetScreenRect();
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 PyObject *resultobj = 0;
31540 wxWindow *arg1 = (wxWindow *) 0 ;
31541 wxSize result;
31542 void *argp1 = 0 ;
31543 int res1 = 0 ;
31544 PyObject *swig_obj[1] ;
31545
31546 if (!args) SWIG_fail;
31547 swig_obj[0] = args;
31548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31549 if (!SWIG_IsOK(res1)) {
31550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31551 }
31552 arg1 = reinterpret_cast< wxWindow * >(argp1);
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 result = ((wxWindow const *)arg1)->GetSize();
31556 wxPyEndAllowThreads(__tstate);
31557 if (PyErr_Occurred()) SWIG_fail;
31558 }
31559 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31560 return resultobj;
31561 fail:
31562 return NULL;
31563 }
31564
31565
31566 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31567 PyObject *resultobj = 0;
31568 wxWindow *arg1 = (wxWindow *) 0 ;
31569 int *arg2 = (int *) 0 ;
31570 int *arg3 = (int *) 0 ;
31571 void *argp1 = 0 ;
31572 int res1 = 0 ;
31573 int temp2 ;
31574 int res2 = SWIG_TMPOBJ ;
31575 int temp3 ;
31576 int res3 = SWIG_TMPOBJ ;
31577 PyObject *swig_obj[1] ;
31578
31579 arg2 = &temp2;
31580 arg3 = &temp3;
31581 if (!args) SWIG_fail;
31582 swig_obj[0] = args;
31583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31584 if (!SWIG_IsOK(res1)) {
31585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31586 }
31587 arg1 = reinterpret_cast< wxWindow * >(argp1);
31588 {
31589 PyThreadState* __tstate = wxPyBeginAllowThreads();
31590 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31591 wxPyEndAllowThreads(__tstate);
31592 if (PyErr_Occurred()) SWIG_fail;
31593 }
31594 resultobj = SWIG_Py_Void();
31595 if (SWIG_IsTmpObj(res2)) {
31596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31597 } else {
31598 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31600 }
31601 if (SWIG_IsTmpObj(res3)) {
31602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31603 } else {
31604 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31606 }
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31614 PyObject *resultobj = 0;
31615 wxWindow *arg1 = (wxWindow *) 0 ;
31616 wxRect result;
31617 void *argp1 = 0 ;
31618 int res1 = 0 ;
31619 PyObject *swig_obj[1] ;
31620
31621 if (!args) SWIG_fail;
31622 swig_obj[0] = args;
31623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31624 if (!SWIG_IsOK(res1)) {
31625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31626 }
31627 arg1 = reinterpret_cast< wxWindow * >(argp1);
31628 {
31629 PyThreadState* __tstate = wxPyBeginAllowThreads();
31630 result = ((wxWindow const *)arg1)->GetRect();
31631 wxPyEndAllowThreads(__tstate);
31632 if (PyErr_Occurred()) SWIG_fail;
31633 }
31634 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31635 return resultobj;
31636 fail:
31637 return NULL;
31638 }
31639
31640
31641 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31642 PyObject *resultobj = 0;
31643 wxWindow *arg1 = (wxWindow *) 0 ;
31644 wxSize result;
31645 void *argp1 = 0 ;
31646 int res1 = 0 ;
31647 PyObject *swig_obj[1] ;
31648
31649 if (!args) SWIG_fail;
31650 swig_obj[0] = args;
31651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31652 if (!SWIG_IsOK(res1)) {
31653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31654 }
31655 arg1 = reinterpret_cast< wxWindow * >(argp1);
31656 {
31657 PyThreadState* __tstate = wxPyBeginAllowThreads();
31658 result = ((wxWindow const *)arg1)->GetClientSize();
31659 wxPyEndAllowThreads(__tstate);
31660 if (PyErr_Occurred()) SWIG_fail;
31661 }
31662 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31663 return resultobj;
31664 fail:
31665 return NULL;
31666 }
31667
31668
31669 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31670 PyObject *resultobj = 0;
31671 wxWindow *arg1 = (wxWindow *) 0 ;
31672 int *arg2 = (int *) 0 ;
31673 int *arg3 = (int *) 0 ;
31674 void *argp1 = 0 ;
31675 int res1 = 0 ;
31676 int temp2 ;
31677 int res2 = SWIG_TMPOBJ ;
31678 int temp3 ;
31679 int res3 = SWIG_TMPOBJ ;
31680 PyObject *swig_obj[1] ;
31681
31682 arg2 = &temp2;
31683 arg3 = &temp3;
31684 if (!args) SWIG_fail;
31685 swig_obj[0] = args;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31689 }
31690 arg1 = reinterpret_cast< wxWindow * >(argp1);
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31694 wxPyEndAllowThreads(__tstate);
31695 if (PyErr_Occurred()) SWIG_fail;
31696 }
31697 resultobj = SWIG_Py_Void();
31698 if (SWIG_IsTmpObj(res2)) {
31699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31700 } else {
31701 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31703 }
31704 if (SWIG_IsTmpObj(res3)) {
31705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31706 } else {
31707 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 wxPoint result;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 PyObject *swig_obj[1] ;
31723
31724 if (!args) SWIG_fail;
31725 swig_obj[0] = args;
31726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31727 if (!SWIG_IsOK(res1)) {
31728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31729 }
31730 arg1 = reinterpret_cast< wxWindow * >(argp1);
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31734 wxPyEndAllowThreads(__tstate);
31735 if (PyErr_Occurred()) SWIG_fail;
31736 }
31737 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31738 return resultobj;
31739 fail:
31740 return NULL;
31741 }
31742
31743
31744 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31745 PyObject *resultobj = 0;
31746 wxWindow *arg1 = (wxWindow *) 0 ;
31747 wxRect result;
31748 void *argp1 = 0 ;
31749 int res1 = 0 ;
31750 PyObject *swig_obj[1] ;
31751
31752 if (!args) SWIG_fail;
31753 swig_obj[0] = args;
31754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31755 if (!SWIG_IsOK(res1)) {
31756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31757 }
31758 arg1 = reinterpret_cast< wxWindow * >(argp1);
31759 {
31760 PyThreadState* __tstate = wxPyBeginAllowThreads();
31761 result = ((wxWindow const *)arg1)->GetClientRect();
31762 wxPyEndAllowThreads(__tstate);
31763 if (PyErr_Occurred()) SWIG_fail;
31764 }
31765 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31766 return resultobj;
31767 fail:
31768 return NULL;
31769 }
31770
31771
31772 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31773 PyObject *resultobj = 0;
31774 wxWindow *arg1 = (wxWindow *) 0 ;
31775 wxSize result;
31776 void *argp1 = 0 ;
31777 int res1 = 0 ;
31778 PyObject *swig_obj[1] ;
31779
31780 if (!args) SWIG_fail;
31781 swig_obj[0] = args;
31782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31783 if (!SWIG_IsOK(res1)) {
31784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31785 }
31786 arg1 = reinterpret_cast< wxWindow * >(argp1);
31787 {
31788 PyThreadState* __tstate = wxPyBeginAllowThreads();
31789 result = ((wxWindow const *)arg1)->GetBestSize();
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31801 PyObject *resultobj = 0;
31802 wxWindow *arg1 = (wxWindow *) 0 ;
31803 int *arg2 = (int *) 0 ;
31804 int *arg3 = (int *) 0 ;
31805 void *argp1 = 0 ;
31806 int res1 = 0 ;
31807 int temp2 ;
31808 int res2 = SWIG_TMPOBJ ;
31809 int temp3 ;
31810 int res3 = SWIG_TMPOBJ ;
31811 PyObject *swig_obj[1] ;
31812
31813 arg2 = &temp2;
31814 arg3 = &temp3;
31815 if (!args) SWIG_fail;
31816 swig_obj[0] = args;
31817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31818 if (!SWIG_IsOK(res1)) {
31819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31820 }
31821 arg1 = reinterpret_cast< wxWindow * >(argp1);
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 if (SWIG_IsTmpObj(res2)) {
31830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31831 } else {
31832 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31834 }
31835 if (SWIG_IsTmpObj(res3)) {
31836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31837 } else {
31838 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31840 }
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31848 PyObject *resultobj = 0;
31849 wxWindow *arg1 = (wxWindow *) 0 ;
31850 void *argp1 = 0 ;
31851 int res1 = 0 ;
31852 PyObject *swig_obj[1] ;
31853
31854 if (!args) SWIG_fail;
31855 swig_obj[0] = args;
31856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31859 }
31860 arg1 = reinterpret_cast< wxWindow * >(argp1);
31861 {
31862 PyThreadState* __tstate = wxPyBeginAllowThreads();
31863 (arg1)->InvalidateBestSize();
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 resultobj = SWIG_Py_Void();
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31875 PyObject *resultobj = 0;
31876 wxWindow *arg1 = (wxWindow *) 0 ;
31877 wxSize *arg2 = 0 ;
31878 void *argp1 = 0 ;
31879 int res1 = 0 ;
31880 wxSize temp2 ;
31881 PyObject * obj0 = 0 ;
31882 PyObject * obj1 = 0 ;
31883 char * kwnames[] = {
31884 (char *) "self",(char *) "size", NULL
31885 };
31886
31887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31889 if (!SWIG_IsOK(res1)) {
31890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31891 }
31892 arg1 = reinterpret_cast< wxWindow * >(argp1);
31893 {
31894 arg2 = &temp2;
31895 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31896 }
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31900 wxPyEndAllowThreads(__tstate);
31901 if (PyErr_Occurred()) SWIG_fail;
31902 }
31903 resultobj = SWIG_Py_Void();
31904 return resultobj;
31905 fail:
31906 return NULL;
31907 }
31908
31909
31910 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31911 PyObject *resultobj = 0;
31912 wxWindow *arg1 = (wxWindow *) 0 ;
31913 wxSize result;
31914 void *argp1 = 0 ;
31915 int res1 = 0 ;
31916 PyObject *swig_obj[1] ;
31917
31918 if (!args) SWIG_fail;
31919 swig_obj[0] = args;
31920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31921 if (!SWIG_IsOK(res1)) {
31922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31923 }
31924 arg1 = reinterpret_cast< wxWindow * >(argp1);
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31939 PyObject *resultobj = 0;
31940 wxWindow *arg1 = (wxWindow *) 0 ;
31941 wxSize result;
31942 void *argp1 = 0 ;
31943 int res1 = 0 ;
31944 PyObject *swig_obj[1] ;
31945
31946 if (!args) SWIG_fail;
31947 swig_obj[0] = args;
31948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31949 if (!SWIG_IsOK(res1)) {
31950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31951 }
31952 arg1 = reinterpret_cast< wxWindow * >(argp1);
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31967 PyObject *resultobj = 0;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 int arg2 = (int) wxBOTH ;
31970 void *argp1 = 0 ;
31971 int res1 = 0 ;
31972 int val2 ;
31973 int ecode2 = 0 ;
31974 PyObject * obj0 = 0 ;
31975 PyObject * obj1 = 0 ;
31976 char * kwnames[] = {
31977 (char *) "self",(char *) "direction", NULL
31978 };
31979
31980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31982 if (!SWIG_IsOK(res1)) {
31983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31984 }
31985 arg1 = reinterpret_cast< wxWindow * >(argp1);
31986 if (obj1) {
31987 ecode2 = SWIG_AsVal_int(obj1, &val2);
31988 if (!SWIG_IsOK(ecode2)) {
31989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31990 }
31991 arg2 = static_cast< int >(val2);
31992 }
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 (arg1)->Center(arg2);
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 resultobj = SWIG_Py_Void();
32000 return resultobj;
32001 fail:
32002 return NULL;
32003 }
32004
32005
32006 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32007 PyObject *resultobj = 0;
32008 wxWindow *arg1 = (wxWindow *) 0 ;
32009 int arg2 = (int) wxBOTH ;
32010 void *argp1 = 0 ;
32011 int res1 = 0 ;
32012 int val2 ;
32013 int ecode2 = 0 ;
32014 PyObject * obj0 = 0 ;
32015 PyObject * obj1 = 0 ;
32016 char * kwnames[] = {
32017 (char *) "self",(char *) "dir", NULL
32018 };
32019
32020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32022 if (!SWIG_IsOK(res1)) {
32023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32024 }
32025 arg1 = reinterpret_cast< wxWindow * >(argp1);
32026 if (obj1) {
32027 ecode2 = SWIG_AsVal_int(obj1, &val2);
32028 if (!SWIG_IsOK(ecode2)) {
32029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32030 }
32031 arg2 = static_cast< int >(val2);
32032 }
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 (arg1)->CenterOnParent(arg2);
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 return resultobj;
32041 fail:
32042 return NULL;
32043 }
32044
32045
32046 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32047 PyObject *resultobj = 0;
32048 wxWindow *arg1 = (wxWindow *) 0 ;
32049 void *argp1 = 0 ;
32050 int res1 = 0 ;
32051 PyObject *swig_obj[1] ;
32052
32053 if (!args) SWIG_fail;
32054 swig_obj[0] = args;
32055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32056 if (!SWIG_IsOK(res1)) {
32057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32058 }
32059 arg1 = reinterpret_cast< wxWindow * >(argp1);
32060 {
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 (arg1)->Fit();
32063 wxPyEndAllowThreads(__tstate);
32064 if (PyErr_Occurred()) SWIG_fail;
32065 }
32066 resultobj = SWIG_Py_Void();
32067 return resultobj;
32068 fail:
32069 return NULL;
32070 }
32071
32072
32073 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32074 PyObject *resultobj = 0;
32075 wxWindow *arg1 = (wxWindow *) 0 ;
32076 void *argp1 = 0 ;
32077 int res1 = 0 ;
32078 PyObject *swig_obj[1] ;
32079
32080 if (!args) SWIG_fail;
32081 swig_obj[0] = args;
32082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32083 if (!SWIG_IsOK(res1)) {
32084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32085 }
32086 arg1 = reinterpret_cast< wxWindow * >(argp1);
32087 {
32088 PyThreadState* __tstate = wxPyBeginAllowThreads();
32089 (arg1)->FitInside();
32090 wxPyEndAllowThreads(__tstate);
32091 if (PyErr_Occurred()) SWIG_fail;
32092 }
32093 resultobj = SWIG_Py_Void();
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj = 0;
32102 wxWindow *arg1 = (wxWindow *) 0 ;
32103 int arg2 ;
32104 int arg3 ;
32105 int arg4 = (int) -1 ;
32106 int arg5 = (int) -1 ;
32107 int arg6 = (int) -1 ;
32108 int arg7 = (int) -1 ;
32109 void *argp1 = 0 ;
32110 int res1 = 0 ;
32111 int val2 ;
32112 int ecode2 = 0 ;
32113 int val3 ;
32114 int ecode3 = 0 ;
32115 int val4 ;
32116 int ecode4 = 0 ;
32117 int val5 ;
32118 int ecode5 = 0 ;
32119 int val6 ;
32120 int ecode6 = 0 ;
32121 int val7 ;
32122 int ecode7 = 0 ;
32123 PyObject * obj0 = 0 ;
32124 PyObject * obj1 = 0 ;
32125 PyObject * obj2 = 0 ;
32126 PyObject * obj3 = 0 ;
32127 PyObject * obj4 = 0 ;
32128 PyObject * obj5 = 0 ;
32129 PyObject * obj6 = 0 ;
32130 char * kwnames[] = {
32131 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32132 };
32133
32134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32136 if (!SWIG_IsOK(res1)) {
32137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32138 }
32139 arg1 = reinterpret_cast< wxWindow * >(argp1);
32140 ecode2 = SWIG_AsVal_int(obj1, &val2);
32141 if (!SWIG_IsOK(ecode2)) {
32142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32143 }
32144 arg2 = static_cast< int >(val2);
32145 ecode3 = SWIG_AsVal_int(obj2, &val3);
32146 if (!SWIG_IsOK(ecode3)) {
32147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32148 }
32149 arg3 = static_cast< int >(val3);
32150 if (obj3) {
32151 ecode4 = SWIG_AsVal_int(obj3, &val4);
32152 if (!SWIG_IsOK(ecode4)) {
32153 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32154 }
32155 arg4 = static_cast< int >(val4);
32156 }
32157 if (obj4) {
32158 ecode5 = SWIG_AsVal_int(obj4, &val5);
32159 if (!SWIG_IsOK(ecode5)) {
32160 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32161 }
32162 arg5 = static_cast< int >(val5);
32163 }
32164 if (obj5) {
32165 ecode6 = SWIG_AsVal_int(obj5, &val6);
32166 if (!SWIG_IsOK(ecode6)) {
32167 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32168 }
32169 arg6 = static_cast< int >(val6);
32170 }
32171 if (obj6) {
32172 ecode7 = SWIG_AsVal_int(obj6, &val7);
32173 if (!SWIG_IsOK(ecode7)) {
32174 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32175 }
32176 arg7 = static_cast< int >(val7);
32177 }
32178 {
32179 PyThreadState* __tstate = wxPyBeginAllowThreads();
32180 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 resultobj = SWIG_Py_Void();
32185 return resultobj;
32186 fail:
32187 return NULL;
32188 }
32189
32190
32191 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32192 PyObject *resultobj = 0;
32193 wxWindow *arg1 = (wxWindow *) 0 ;
32194 wxSize *arg2 = 0 ;
32195 wxSize const &arg3_defvalue = wxDefaultSize ;
32196 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32197 wxSize const &arg4_defvalue = wxDefaultSize ;
32198 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32199 void *argp1 = 0 ;
32200 int res1 = 0 ;
32201 wxSize temp2 ;
32202 wxSize temp3 ;
32203 wxSize temp4 ;
32204 PyObject * obj0 = 0 ;
32205 PyObject * obj1 = 0 ;
32206 PyObject * obj2 = 0 ;
32207 PyObject * obj3 = 0 ;
32208 char * kwnames[] = {
32209 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32210 };
32211
32212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32216 }
32217 arg1 = reinterpret_cast< wxWindow * >(argp1);
32218 {
32219 arg2 = &temp2;
32220 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32221 }
32222 if (obj2) {
32223 {
32224 arg3 = &temp3;
32225 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32226 }
32227 }
32228 if (obj3) {
32229 {
32230 arg4 = &temp4;
32231 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32232 }
32233 }
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 resultobj = SWIG_Py_Void();
32241 return resultobj;
32242 fail:
32243 return NULL;
32244 }
32245
32246
32247 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32248 PyObject *resultobj = 0;
32249 wxWindow *arg1 = (wxWindow *) 0 ;
32250 int arg2 ;
32251 int arg3 ;
32252 int arg4 = (int) -1 ;
32253 int arg5 = (int) -1 ;
32254 void *argp1 = 0 ;
32255 int res1 = 0 ;
32256 int val2 ;
32257 int ecode2 = 0 ;
32258 int val3 ;
32259 int ecode3 = 0 ;
32260 int val4 ;
32261 int ecode4 = 0 ;
32262 int val5 ;
32263 int ecode5 = 0 ;
32264 PyObject * obj0 = 0 ;
32265 PyObject * obj1 = 0 ;
32266 PyObject * obj2 = 0 ;
32267 PyObject * obj3 = 0 ;
32268 PyObject * obj4 = 0 ;
32269 char * kwnames[] = {
32270 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32271 };
32272
32273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32275 if (!SWIG_IsOK(res1)) {
32276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32277 }
32278 arg1 = reinterpret_cast< wxWindow * >(argp1);
32279 ecode2 = SWIG_AsVal_int(obj1, &val2);
32280 if (!SWIG_IsOK(ecode2)) {
32281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32282 }
32283 arg2 = static_cast< int >(val2);
32284 ecode3 = SWIG_AsVal_int(obj2, &val3);
32285 if (!SWIG_IsOK(ecode3)) {
32286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32287 }
32288 arg3 = static_cast< int >(val3);
32289 if (obj3) {
32290 ecode4 = SWIG_AsVal_int(obj3, &val4);
32291 if (!SWIG_IsOK(ecode4)) {
32292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32293 }
32294 arg4 = static_cast< int >(val4);
32295 }
32296 if (obj4) {
32297 ecode5 = SWIG_AsVal_int(obj4, &val5);
32298 if (!SWIG_IsOK(ecode5)) {
32299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32300 }
32301 arg5 = static_cast< int >(val5);
32302 }
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 resultobj = SWIG_Py_Void();
32310 return resultobj;
32311 fail:
32312 return NULL;
32313 }
32314
32315
32316 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32317 PyObject *resultobj = 0;
32318 wxWindow *arg1 = (wxWindow *) 0 ;
32319 wxSize *arg2 = 0 ;
32320 wxSize const &arg3_defvalue = wxDefaultSize ;
32321 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32322 void *argp1 = 0 ;
32323 int res1 = 0 ;
32324 wxSize temp2 ;
32325 wxSize temp3 ;
32326 PyObject * obj0 = 0 ;
32327 PyObject * obj1 = 0 ;
32328 PyObject * obj2 = 0 ;
32329 char * kwnames[] = {
32330 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32331 };
32332
32333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32335 if (!SWIG_IsOK(res1)) {
32336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32337 }
32338 arg1 = reinterpret_cast< wxWindow * >(argp1);
32339 {
32340 arg2 = &temp2;
32341 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32342 }
32343 if (obj2) {
32344 {
32345 arg3 = &temp3;
32346 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32347 }
32348 }
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32352 wxPyEndAllowThreads(__tstate);
32353 if (PyErr_Occurred()) SWIG_fail;
32354 }
32355 resultobj = SWIG_Py_Void();
32356 return resultobj;
32357 fail:
32358 return NULL;
32359 }
32360
32361
32362 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32363 PyObject *resultobj = 0;
32364 wxWindow *arg1 = (wxWindow *) 0 ;
32365 wxSize result;
32366 void *argp1 = 0 ;
32367 int res1 = 0 ;
32368 PyObject *swig_obj[1] ;
32369
32370 if (!args) SWIG_fail;
32371 swig_obj[0] = args;
32372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32373 if (!SWIG_IsOK(res1)) {
32374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32375 }
32376 arg1 = reinterpret_cast< wxWindow * >(argp1);
32377 {
32378 PyThreadState* __tstate = wxPyBeginAllowThreads();
32379 result = ((wxWindow const *)arg1)->GetMaxSize();
32380 wxPyEndAllowThreads(__tstate);
32381 if (PyErr_Occurred()) SWIG_fail;
32382 }
32383 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32384 return resultobj;
32385 fail:
32386 return NULL;
32387 }
32388
32389
32390 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32391 PyObject *resultobj = 0;
32392 wxWindow *arg1 = (wxWindow *) 0 ;
32393 wxSize result;
32394 void *argp1 = 0 ;
32395 int res1 = 0 ;
32396 PyObject *swig_obj[1] ;
32397
32398 if (!args) SWIG_fail;
32399 swig_obj[0] = args;
32400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32401 if (!SWIG_IsOK(res1)) {
32402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32403 }
32404 arg1 = reinterpret_cast< wxWindow * >(argp1);
32405 {
32406 PyThreadState* __tstate = wxPyBeginAllowThreads();
32407 result = ((wxWindow const *)arg1)->GetMinSize();
32408 wxPyEndAllowThreads(__tstate);
32409 if (PyErr_Occurred()) SWIG_fail;
32410 }
32411 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32412 return resultobj;
32413 fail:
32414 return NULL;
32415 }
32416
32417
32418 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32419 PyObject *resultobj = 0;
32420 wxWindow *arg1 = (wxWindow *) 0 ;
32421 wxSize *arg2 = 0 ;
32422 void *argp1 = 0 ;
32423 int res1 = 0 ;
32424 wxSize temp2 ;
32425 PyObject * obj0 = 0 ;
32426 PyObject * obj1 = 0 ;
32427 char * kwnames[] = {
32428 (char *) "self",(char *) "minSize", NULL
32429 };
32430
32431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32433 if (!SWIG_IsOK(res1)) {
32434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32435 }
32436 arg1 = reinterpret_cast< wxWindow * >(argp1);
32437 {
32438 arg2 = &temp2;
32439 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32440 }
32441 {
32442 PyThreadState* __tstate = wxPyBeginAllowThreads();
32443 (arg1)->SetMinSize((wxSize const &)*arg2);
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 resultobj = SWIG_Py_Void();
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32455 PyObject *resultobj = 0;
32456 wxWindow *arg1 = (wxWindow *) 0 ;
32457 wxSize *arg2 = 0 ;
32458 void *argp1 = 0 ;
32459 int res1 = 0 ;
32460 wxSize temp2 ;
32461 PyObject * obj0 = 0 ;
32462 PyObject * obj1 = 0 ;
32463 char * kwnames[] = {
32464 (char *) "self",(char *) "maxSize", NULL
32465 };
32466
32467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32469 if (!SWIG_IsOK(res1)) {
32470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32471 }
32472 arg1 = reinterpret_cast< wxWindow * >(argp1);
32473 {
32474 arg2 = &temp2;
32475 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32476 }
32477 {
32478 PyThreadState* __tstate = wxPyBeginAllowThreads();
32479 (arg1)->SetMaxSize((wxSize const &)*arg2);
32480 wxPyEndAllowThreads(__tstate);
32481 if (PyErr_Occurred()) SWIG_fail;
32482 }
32483 resultobj = SWIG_Py_Void();
32484 return resultobj;
32485 fail:
32486 return NULL;
32487 }
32488
32489
32490 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32491 PyObject *resultobj = 0;
32492 wxWindow *arg1 = (wxWindow *) 0 ;
32493 int result;
32494 void *argp1 = 0 ;
32495 int res1 = 0 ;
32496 PyObject *swig_obj[1] ;
32497
32498 if (!args) SWIG_fail;
32499 swig_obj[0] = args;
32500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32501 if (!SWIG_IsOK(res1)) {
32502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32503 }
32504 arg1 = reinterpret_cast< wxWindow * >(argp1);
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32508 wxPyEndAllowThreads(__tstate);
32509 if (PyErr_Occurred()) SWIG_fail;
32510 }
32511 resultobj = SWIG_From_int(static_cast< int >(result));
32512 return resultobj;
32513 fail:
32514 return NULL;
32515 }
32516
32517
32518 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32519 PyObject *resultobj = 0;
32520 wxWindow *arg1 = (wxWindow *) 0 ;
32521 int result;
32522 void *argp1 = 0 ;
32523 int res1 = 0 ;
32524 PyObject *swig_obj[1] ;
32525
32526 if (!args) SWIG_fail;
32527 swig_obj[0] = args;
32528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32529 if (!SWIG_IsOK(res1)) {
32530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32531 }
32532 arg1 = reinterpret_cast< wxWindow * >(argp1);
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 resultobj = SWIG_From_int(static_cast< int >(result));
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxWindow *arg1 = (wxWindow *) 0 ;
32549 int result;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32559 }
32560 arg1 = reinterpret_cast< wxWindow * >(argp1);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_From_int(static_cast< int >(result));
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 PyObject *resultobj = 0;
32576 wxWindow *arg1 = (wxWindow *) 0 ;
32577 int result;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject *swig_obj[1] ;
32581
32582 if (!args) SWIG_fail;
32583 swig_obj[0] = args;
32584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32585 if (!SWIG_IsOK(res1)) {
32586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32587 }
32588 arg1 = reinterpret_cast< wxWindow * >(argp1);
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 resultobj = SWIG_From_int(static_cast< int >(result));
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32603 PyObject *resultobj = 0;
32604 wxWindow *arg1 = (wxWindow *) 0 ;
32605 wxSize *arg2 = 0 ;
32606 void *argp1 = 0 ;
32607 int res1 = 0 ;
32608 wxSize temp2 ;
32609 PyObject * obj0 = 0 ;
32610 PyObject * obj1 = 0 ;
32611 char * kwnames[] = {
32612 (char *) "self",(char *) "size", NULL
32613 };
32614
32615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32619 }
32620 arg1 = reinterpret_cast< wxWindow * >(argp1);
32621 {
32622 arg2 = &temp2;
32623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32624 }
32625 {
32626 PyThreadState* __tstate = wxPyBeginAllowThreads();
32627 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32628 wxPyEndAllowThreads(__tstate);
32629 if (PyErr_Occurred()) SWIG_fail;
32630 }
32631 resultobj = SWIG_Py_Void();
32632 return resultobj;
32633 fail:
32634 return NULL;
32635 }
32636
32637
32638 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32639 PyObject *resultobj = 0;
32640 wxWindow *arg1 = (wxWindow *) 0 ;
32641 int arg2 ;
32642 int arg3 ;
32643 void *argp1 = 0 ;
32644 int res1 = 0 ;
32645 int val2 ;
32646 int ecode2 = 0 ;
32647 int val3 ;
32648 int ecode3 = 0 ;
32649 PyObject * obj0 = 0 ;
32650 PyObject * obj1 = 0 ;
32651 PyObject * obj2 = 0 ;
32652 char * kwnames[] = {
32653 (char *) "self",(char *) "w",(char *) "h", NULL
32654 };
32655
32656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32658 if (!SWIG_IsOK(res1)) {
32659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32660 }
32661 arg1 = reinterpret_cast< wxWindow * >(argp1);
32662 ecode2 = SWIG_AsVal_int(obj1, &val2);
32663 if (!SWIG_IsOK(ecode2)) {
32664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32665 }
32666 arg2 = static_cast< int >(val2);
32667 ecode3 = SWIG_AsVal_int(obj2, &val3);
32668 if (!SWIG_IsOK(ecode3)) {
32669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32670 }
32671 arg3 = static_cast< int >(val3);
32672 {
32673 PyThreadState* __tstate = wxPyBeginAllowThreads();
32674 (arg1)->SetVirtualSize(arg2,arg3);
32675 wxPyEndAllowThreads(__tstate);
32676 if (PyErr_Occurred()) SWIG_fail;
32677 }
32678 resultobj = SWIG_Py_Void();
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32686 PyObject *resultobj = 0;
32687 wxWindow *arg1 = (wxWindow *) 0 ;
32688 wxSize result;
32689 void *argp1 = 0 ;
32690 int res1 = 0 ;
32691 PyObject *swig_obj[1] ;
32692
32693 if (!args) SWIG_fail;
32694 swig_obj[0] = args;
32695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32696 if (!SWIG_IsOK(res1)) {
32697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32698 }
32699 arg1 = reinterpret_cast< wxWindow * >(argp1);
32700 {
32701 PyThreadState* __tstate = wxPyBeginAllowThreads();
32702 result = ((wxWindow const *)arg1)->GetVirtualSize();
32703 wxPyEndAllowThreads(__tstate);
32704 if (PyErr_Occurred()) SWIG_fail;
32705 }
32706 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32714 PyObject *resultobj = 0;
32715 wxWindow *arg1 = (wxWindow *) 0 ;
32716 int *arg2 = (int *) 0 ;
32717 int *arg3 = (int *) 0 ;
32718 void *argp1 = 0 ;
32719 int res1 = 0 ;
32720 int temp2 ;
32721 int res2 = SWIG_TMPOBJ ;
32722 int temp3 ;
32723 int res3 = SWIG_TMPOBJ ;
32724 PyObject *swig_obj[1] ;
32725
32726 arg2 = &temp2;
32727 arg3 = &temp3;
32728 if (!args) SWIG_fail;
32729 swig_obj[0] = args;
32730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32731 if (!SWIG_IsOK(res1)) {
32732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32733 }
32734 arg1 = reinterpret_cast< wxWindow * >(argp1);
32735 {
32736 PyThreadState* __tstate = wxPyBeginAllowThreads();
32737 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32738 wxPyEndAllowThreads(__tstate);
32739 if (PyErr_Occurred()) SWIG_fail;
32740 }
32741 resultobj = SWIG_Py_Void();
32742 if (SWIG_IsTmpObj(res2)) {
32743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32744 } else {
32745 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32747 }
32748 if (SWIG_IsTmpObj(res3)) {
32749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32750 } else {
32751 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32753 }
32754 return resultobj;
32755 fail:
32756 return NULL;
32757 }
32758
32759
32760 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32761 PyObject *resultobj = 0;
32762 wxWindow *arg1 = (wxWindow *) 0 ;
32763 wxSize result;
32764 void *argp1 = 0 ;
32765 int res1 = 0 ;
32766 PyObject *swig_obj[1] ;
32767
32768 if (!args) SWIG_fail;
32769 swig_obj[0] = args;
32770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32771 if (!SWIG_IsOK(res1)) {
32772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32773 }
32774 arg1 = reinterpret_cast< wxWindow * >(argp1);
32775 {
32776 PyThreadState* __tstate = wxPyBeginAllowThreads();
32777 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32789 PyObject *resultobj = 0;
32790 wxWindow *arg1 = (wxWindow *) 0 ;
32791 bool arg2 = (bool) true ;
32792 bool result;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 bool val2 ;
32796 int ecode2 = 0 ;
32797 PyObject * obj0 = 0 ;
32798 PyObject * obj1 = 0 ;
32799 char * kwnames[] = {
32800 (char *) "self",(char *) "show", NULL
32801 };
32802
32803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 if (obj1) {
32810 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32811 if (!SWIG_IsOK(ecode2)) {
32812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32813 }
32814 arg2 = static_cast< bool >(val2);
32815 }
32816 {
32817 PyThreadState* __tstate = wxPyBeginAllowThreads();
32818 result = (bool)(arg1)->Show(arg2);
32819 wxPyEndAllowThreads(__tstate);
32820 if (PyErr_Occurred()) SWIG_fail;
32821 }
32822 {
32823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32824 }
32825 return resultobj;
32826 fail:
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32832 PyObject *resultobj = 0;
32833 wxWindow *arg1 = (wxWindow *) 0 ;
32834 bool result;
32835 void *argp1 = 0 ;
32836 int res1 = 0 ;
32837 PyObject *swig_obj[1] ;
32838
32839 if (!args) SWIG_fail;
32840 swig_obj[0] = args;
32841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32842 if (!SWIG_IsOK(res1)) {
32843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32844 }
32845 arg1 = reinterpret_cast< wxWindow * >(argp1);
32846 {
32847 PyThreadState* __tstate = wxPyBeginAllowThreads();
32848 result = (bool)(arg1)->Hide();
32849 wxPyEndAllowThreads(__tstate);
32850 if (PyErr_Occurred()) SWIG_fail;
32851 }
32852 {
32853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32854 }
32855 return resultobj;
32856 fail:
32857 return NULL;
32858 }
32859
32860
32861 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32862 PyObject *resultobj = 0;
32863 wxWindow *arg1 = (wxWindow *) 0 ;
32864 bool arg2 = (bool) true ;
32865 bool result;
32866 void *argp1 = 0 ;
32867 int res1 = 0 ;
32868 bool val2 ;
32869 int ecode2 = 0 ;
32870 PyObject * obj0 = 0 ;
32871 PyObject * obj1 = 0 ;
32872 char * kwnames[] = {
32873 (char *) "self",(char *) "enable", NULL
32874 };
32875
32876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32878 if (!SWIG_IsOK(res1)) {
32879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32880 }
32881 arg1 = reinterpret_cast< wxWindow * >(argp1);
32882 if (obj1) {
32883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32884 if (!SWIG_IsOK(ecode2)) {
32885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32886 }
32887 arg2 = static_cast< bool >(val2);
32888 }
32889 {
32890 PyThreadState* __tstate = wxPyBeginAllowThreads();
32891 result = (bool)(arg1)->Enable(arg2);
32892 wxPyEndAllowThreads(__tstate);
32893 if (PyErr_Occurred()) SWIG_fail;
32894 }
32895 {
32896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32897 }
32898 return resultobj;
32899 fail:
32900 return NULL;
32901 }
32902
32903
32904 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32905 PyObject *resultobj = 0;
32906 wxWindow *arg1 = (wxWindow *) 0 ;
32907 bool result;
32908 void *argp1 = 0 ;
32909 int res1 = 0 ;
32910 PyObject *swig_obj[1] ;
32911
32912 if (!args) SWIG_fail;
32913 swig_obj[0] = args;
32914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32917 }
32918 arg1 = reinterpret_cast< wxWindow * >(argp1);
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 result = (bool)(arg1)->Disable();
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 {
32926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32927 }
32928 return resultobj;
32929 fail:
32930 return NULL;
32931 }
32932
32933
32934 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32935 PyObject *resultobj = 0;
32936 wxWindow *arg1 = (wxWindow *) 0 ;
32937 bool result;
32938 void *argp1 = 0 ;
32939 int res1 = 0 ;
32940 PyObject *swig_obj[1] ;
32941
32942 if (!args) SWIG_fail;
32943 swig_obj[0] = args;
32944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32945 if (!SWIG_IsOK(res1)) {
32946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32947 }
32948 arg1 = reinterpret_cast< wxWindow * >(argp1);
32949 {
32950 PyThreadState* __tstate = wxPyBeginAllowThreads();
32951 result = (bool)((wxWindow const *)arg1)->IsShown();
32952 wxPyEndAllowThreads(__tstate);
32953 if (PyErr_Occurred()) SWIG_fail;
32954 }
32955 {
32956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32957 }
32958 return resultobj;
32959 fail:
32960 return NULL;
32961 }
32962
32963
32964 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32965 PyObject *resultobj = 0;
32966 wxWindow *arg1 = (wxWindow *) 0 ;
32967 bool result;
32968 void *argp1 = 0 ;
32969 int res1 = 0 ;
32970 PyObject *swig_obj[1] ;
32971
32972 if (!args) SWIG_fail;
32973 swig_obj[0] = args;
32974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32975 if (!SWIG_IsOK(res1)) {
32976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32977 }
32978 arg1 = reinterpret_cast< wxWindow * >(argp1);
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 {
32986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32987 }
32988 return resultobj;
32989 fail:
32990 return NULL;
32991 }
32992
32993
32994 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 PyObject *resultobj = 0;
32996 wxWindow *arg1 = (wxWindow *) 0 ;
32997 bool result;
32998 void *argp1 = 0 ;
32999 int res1 = 0 ;
33000 PyObject *swig_obj[1] ;
33001
33002 if (!args) SWIG_fail;
33003 swig_obj[0] = args;
33004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33007 }
33008 arg1 = reinterpret_cast< wxWindow * >(argp1);
33009 {
33010 PyThreadState* __tstate = wxPyBeginAllowThreads();
33011 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 {
33016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33017 }
33018 return resultobj;
33019 fail:
33020 return NULL;
33021 }
33022
33023
33024 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33025 PyObject *resultobj = 0;
33026 wxWindow *arg1 = (wxWindow *) 0 ;
33027 long arg2 ;
33028 void *argp1 = 0 ;
33029 int res1 = 0 ;
33030 long val2 ;
33031 int ecode2 = 0 ;
33032 PyObject * obj0 = 0 ;
33033 PyObject * obj1 = 0 ;
33034 char * kwnames[] = {
33035 (char *) "self",(char *) "style", NULL
33036 };
33037
33038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33040 if (!SWIG_IsOK(res1)) {
33041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33042 }
33043 arg1 = reinterpret_cast< wxWindow * >(argp1);
33044 ecode2 = SWIG_AsVal_long(obj1, &val2);
33045 if (!SWIG_IsOK(ecode2)) {
33046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33047 }
33048 arg2 = static_cast< long >(val2);
33049 {
33050 PyThreadState* __tstate = wxPyBeginAllowThreads();
33051 (arg1)->SetWindowStyleFlag(arg2);
33052 wxPyEndAllowThreads(__tstate);
33053 if (PyErr_Occurred()) SWIG_fail;
33054 }
33055 resultobj = SWIG_Py_Void();
33056 return resultobj;
33057 fail:
33058 return NULL;
33059 }
33060
33061
33062 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33063 PyObject *resultobj = 0;
33064 wxWindow *arg1 = (wxWindow *) 0 ;
33065 long result;
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_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33075 }
33076 arg1 = reinterpret_cast< wxWindow * >(argp1);
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 resultobj = SWIG_From_long(static_cast< long >(result));
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33091 PyObject *resultobj = 0;
33092 wxWindow *arg1 = (wxWindow *) 0 ;
33093 int arg2 ;
33094 bool result;
33095 void *argp1 = 0 ;
33096 int res1 = 0 ;
33097 int val2 ;
33098 int ecode2 = 0 ;
33099 PyObject * obj0 = 0 ;
33100 PyObject * obj1 = 0 ;
33101 char * kwnames[] = {
33102 (char *) "self",(char *) "flag", NULL
33103 };
33104
33105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33109 }
33110 arg1 = reinterpret_cast< wxWindow * >(argp1);
33111 ecode2 = SWIG_AsVal_int(obj1, &val2);
33112 if (!SWIG_IsOK(ecode2)) {
33113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33114 }
33115 arg2 = static_cast< int >(val2);
33116 {
33117 PyThreadState* __tstate = wxPyBeginAllowThreads();
33118 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33119 wxPyEndAllowThreads(__tstate);
33120 if (PyErr_Occurred()) SWIG_fail;
33121 }
33122 {
33123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33124 }
33125 return resultobj;
33126 fail:
33127 return NULL;
33128 }
33129
33130
33131 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33132 PyObject *resultobj = 0;
33133 wxWindow *arg1 = (wxWindow *) 0 ;
33134 bool result;
33135 void *argp1 = 0 ;
33136 int res1 = 0 ;
33137 PyObject *swig_obj[1] ;
33138
33139 if (!args) SWIG_fail;
33140 swig_obj[0] = args;
33141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33142 if (!SWIG_IsOK(res1)) {
33143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33144 }
33145 arg1 = reinterpret_cast< wxWindow * >(argp1);
33146 {
33147 PyThreadState* __tstate = wxPyBeginAllowThreads();
33148 result = (bool)((wxWindow const *)arg1)->IsRetained();
33149 wxPyEndAllowThreads(__tstate);
33150 if (PyErr_Occurred()) SWIG_fail;
33151 }
33152 {
33153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33154 }
33155 return resultobj;
33156 fail:
33157 return NULL;
33158 }
33159
33160
33161 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33162 PyObject *resultobj = 0;
33163 wxWindow *arg1 = (wxWindow *) 0 ;
33164 long arg2 ;
33165 void *argp1 = 0 ;
33166 int res1 = 0 ;
33167 long val2 ;
33168 int ecode2 = 0 ;
33169 PyObject * obj0 = 0 ;
33170 PyObject * obj1 = 0 ;
33171 char * kwnames[] = {
33172 (char *) "self",(char *) "exStyle", NULL
33173 };
33174
33175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33179 }
33180 arg1 = reinterpret_cast< wxWindow * >(argp1);
33181 ecode2 = SWIG_AsVal_long(obj1, &val2);
33182 if (!SWIG_IsOK(ecode2)) {
33183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33184 }
33185 arg2 = static_cast< long >(val2);
33186 {
33187 PyThreadState* __tstate = wxPyBeginAllowThreads();
33188 (arg1)->SetExtraStyle(arg2);
33189 wxPyEndAllowThreads(__tstate);
33190 if (PyErr_Occurred()) SWIG_fail;
33191 }
33192 resultobj = SWIG_Py_Void();
33193 return resultobj;
33194 fail:
33195 return NULL;
33196 }
33197
33198
33199 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33200 PyObject *resultobj = 0;
33201 wxWindow *arg1 = (wxWindow *) 0 ;
33202 long result;
33203 void *argp1 = 0 ;
33204 int res1 = 0 ;
33205 PyObject *swig_obj[1] ;
33206
33207 if (!args) SWIG_fail;
33208 swig_obj[0] = args;
33209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33210 if (!SWIG_IsOK(res1)) {
33211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33212 }
33213 arg1 = reinterpret_cast< wxWindow * >(argp1);
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33217 wxPyEndAllowThreads(__tstate);
33218 if (PyErr_Occurred()) SWIG_fail;
33219 }
33220 resultobj = SWIG_From_long(static_cast< long >(result));
33221 return resultobj;
33222 fail:
33223 return NULL;
33224 }
33225
33226
33227 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 bool arg2 = (bool) true ;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 bool val2 ;
33234 int ecode2 = 0 ;
33235 PyObject * obj0 = 0 ;
33236 PyObject * obj1 = 0 ;
33237 char * kwnames[] = {
33238 (char *) "self",(char *) "modal", NULL
33239 };
33240
33241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33245 }
33246 arg1 = reinterpret_cast< wxWindow * >(argp1);
33247 if (obj1) {
33248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33249 if (!SWIG_IsOK(ecode2)) {
33250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33251 }
33252 arg2 = static_cast< bool >(val2);
33253 }
33254 {
33255 PyThreadState* __tstate = wxPyBeginAllowThreads();
33256 (arg1)->MakeModal(arg2);
33257 wxPyEndAllowThreads(__tstate);
33258 if (PyErr_Occurred()) SWIG_fail;
33259 }
33260 resultobj = SWIG_Py_Void();
33261 return resultobj;
33262 fail:
33263 return NULL;
33264 }
33265
33266
33267 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33268 PyObject *resultobj = 0;
33269 wxWindow *arg1 = (wxWindow *) 0 ;
33270 bool arg2 ;
33271 void *argp1 = 0 ;
33272 int res1 = 0 ;
33273 bool val2 ;
33274 int ecode2 = 0 ;
33275 PyObject * obj0 = 0 ;
33276 PyObject * obj1 = 0 ;
33277 char * kwnames[] = {
33278 (char *) "self",(char *) "enableTheme", NULL
33279 };
33280
33281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33283 if (!SWIG_IsOK(res1)) {
33284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33285 }
33286 arg1 = reinterpret_cast< wxWindow * >(argp1);
33287 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33288 if (!SWIG_IsOK(ecode2)) {
33289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33290 }
33291 arg2 = static_cast< bool >(val2);
33292 {
33293 PyThreadState* __tstate = wxPyBeginAllowThreads();
33294 (arg1)->SetThemeEnabled(arg2);
33295 wxPyEndAllowThreads(__tstate);
33296 if (PyErr_Occurred()) SWIG_fail;
33297 }
33298 resultobj = SWIG_Py_Void();
33299 return resultobj;
33300 fail:
33301 return NULL;
33302 }
33303
33304
33305 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33306 PyObject *resultobj = 0;
33307 wxWindow *arg1 = (wxWindow *) 0 ;
33308 bool result;
33309 void *argp1 = 0 ;
33310 int res1 = 0 ;
33311 PyObject *swig_obj[1] ;
33312
33313 if (!args) SWIG_fail;
33314 swig_obj[0] = args;
33315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33316 if (!SWIG_IsOK(res1)) {
33317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33318 }
33319 arg1 = reinterpret_cast< wxWindow * >(argp1);
33320 {
33321 PyThreadState* __tstate = wxPyBeginAllowThreads();
33322 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33323 wxPyEndAllowThreads(__tstate);
33324 if (PyErr_Occurred()) SWIG_fail;
33325 }
33326 {
33327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33328 }
33329 return resultobj;
33330 fail:
33331 return NULL;
33332 }
33333
33334
33335 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33336 PyObject *resultobj = 0;
33337 wxWindow *arg1 = (wxWindow *) 0 ;
33338 void *argp1 = 0 ;
33339 int res1 = 0 ;
33340 PyObject *swig_obj[1] ;
33341
33342 if (!args) SWIG_fail;
33343 swig_obj[0] = args;
33344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33345 if (!SWIG_IsOK(res1)) {
33346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33347 }
33348 arg1 = reinterpret_cast< wxWindow * >(argp1);
33349 {
33350 PyThreadState* __tstate = wxPyBeginAllowThreads();
33351 (arg1)->SetFocus();
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 resultobj = SWIG_Py_Void();
33356 return resultobj;
33357 fail:
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33363 PyObject *resultobj = 0;
33364 wxWindow *arg1 = (wxWindow *) 0 ;
33365 void *argp1 = 0 ;
33366 int res1 = 0 ;
33367 PyObject *swig_obj[1] ;
33368
33369 if (!args) SWIG_fail;
33370 swig_obj[0] = args;
33371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33372 if (!SWIG_IsOK(res1)) {
33373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33374 }
33375 arg1 = reinterpret_cast< wxWindow * >(argp1);
33376 {
33377 PyThreadState* __tstate = wxPyBeginAllowThreads();
33378 (arg1)->SetFocusFromKbd();
33379 wxPyEndAllowThreads(__tstate);
33380 if (PyErr_Occurred()) SWIG_fail;
33381 }
33382 resultobj = SWIG_Py_Void();
33383 return resultobj;
33384 fail:
33385 return NULL;
33386 }
33387
33388
33389 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33390 PyObject *resultobj = 0;
33391 wxWindow *result = 0 ;
33392
33393 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33394 {
33395 if (!wxPyCheckForApp()) SWIG_fail;
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 result = (wxWindow *)wxWindow::FindFocus();
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 {
33402 resultobj = wxPyMake_wxObject(result, 0);
33403 }
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *resultobj = 0;
33412 wxWindow *arg1 = (wxWindow *) 0 ;
33413 bool result;
33414 void *argp1 = 0 ;
33415 int res1 = 0 ;
33416 PyObject *swig_obj[1] ;
33417
33418 if (!args) SWIG_fail;
33419 swig_obj[0] = args;
33420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33423 }
33424 arg1 = reinterpret_cast< wxWindow * >(argp1);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 {
33432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33433 }
33434 return resultobj;
33435 fail:
33436 return NULL;
33437 }
33438
33439
33440 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33441 PyObject *resultobj = 0;
33442 wxWindow *arg1 = (wxWindow *) 0 ;
33443 bool result;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 PyObject *swig_obj[1] ;
33447
33448 if (!args) SWIG_fail;
33449 swig_obj[0] = args;
33450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33453 }
33454 arg1 = reinterpret_cast< wxWindow * >(argp1);
33455 {
33456 PyThreadState* __tstate = wxPyBeginAllowThreads();
33457 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33458 wxPyEndAllowThreads(__tstate);
33459 if (PyErr_Occurred()) SWIG_fail;
33460 }
33461 {
33462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33463 }
33464 return resultobj;
33465 fail:
33466 return NULL;
33467 }
33468
33469
33470 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33471 PyObject *resultobj = 0;
33472 wxWindow *arg1 = (wxWindow *) 0 ;
33473 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33474 bool result;
33475 void *argp1 = 0 ;
33476 int res1 = 0 ;
33477 int val2 ;
33478 int ecode2 = 0 ;
33479 PyObject * obj0 = 0 ;
33480 PyObject * obj1 = 0 ;
33481 char * kwnames[] = {
33482 (char *) "self",(char *) "flags", NULL
33483 };
33484
33485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33487 if (!SWIG_IsOK(res1)) {
33488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33489 }
33490 arg1 = reinterpret_cast< wxWindow * >(argp1);
33491 if (obj1) {
33492 ecode2 = SWIG_AsVal_int(obj1, &val2);
33493 if (!SWIG_IsOK(ecode2)) {
33494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33495 }
33496 arg2 = static_cast< int >(val2);
33497 }
33498 {
33499 PyThreadState* __tstate = wxPyBeginAllowThreads();
33500 result = (bool)(arg1)->Navigate(arg2);
33501 wxPyEndAllowThreads(__tstate);
33502 if (PyErr_Occurred()) SWIG_fail;
33503 }
33504 {
33505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33506 }
33507 return resultobj;
33508 fail:
33509 return NULL;
33510 }
33511
33512
33513 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33514 PyObject *resultobj = 0;
33515 wxWindow *arg1 = (wxWindow *) 0 ;
33516 wxWindow *arg2 = (wxWindow *) 0 ;
33517 void *argp1 = 0 ;
33518 int res1 = 0 ;
33519 void *argp2 = 0 ;
33520 int res2 = 0 ;
33521 PyObject * obj0 = 0 ;
33522 PyObject * obj1 = 0 ;
33523 char * kwnames[] = {
33524 (char *) "self",(char *) "win", NULL
33525 };
33526
33527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33529 if (!SWIG_IsOK(res1)) {
33530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33531 }
33532 arg1 = reinterpret_cast< wxWindow * >(argp1);
33533 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res2)) {
33535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33536 }
33537 arg2 = reinterpret_cast< wxWindow * >(argp2);
33538 {
33539 PyThreadState* __tstate = wxPyBeginAllowThreads();
33540 (arg1)->MoveAfterInTabOrder(arg2);
33541 wxPyEndAllowThreads(__tstate);
33542 if (PyErr_Occurred()) SWIG_fail;
33543 }
33544 resultobj = SWIG_Py_Void();
33545 return resultobj;
33546 fail:
33547 return NULL;
33548 }
33549
33550
33551 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33552 PyObject *resultobj = 0;
33553 wxWindow *arg1 = (wxWindow *) 0 ;
33554 wxWindow *arg2 = (wxWindow *) 0 ;
33555 void *argp1 = 0 ;
33556 int res1 = 0 ;
33557 void *argp2 = 0 ;
33558 int res2 = 0 ;
33559 PyObject * obj0 = 0 ;
33560 PyObject * obj1 = 0 ;
33561 char * kwnames[] = {
33562 (char *) "self",(char *) "win", NULL
33563 };
33564
33565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33567 if (!SWIG_IsOK(res1)) {
33568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33569 }
33570 arg1 = reinterpret_cast< wxWindow * >(argp1);
33571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33572 if (!SWIG_IsOK(res2)) {
33573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33574 }
33575 arg2 = reinterpret_cast< wxWindow * >(argp2);
33576 {
33577 PyThreadState* __tstate = wxPyBeginAllowThreads();
33578 (arg1)->MoveBeforeInTabOrder(arg2);
33579 wxPyEndAllowThreads(__tstate);
33580 if (PyErr_Occurred()) SWIG_fail;
33581 }
33582 resultobj = SWIG_Py_Void();
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33590 PyObject *resultobj = 0;
33591 wxWindow *arg1 = (wxWindow *) 0 ;
33592 PyObject *result = 0 ;
33593 void *argp1 = 0 ;
33594 int res1 = 0 ;
33595 PyObject *swig_obj[1] ;
33596
33597 if (!args) SWIG_fail;
33598 swig_obj[0] = args;
33599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33600 if (!SWIG_IsOK(res1)) {
33601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33602 }
33603 arg1 = reinterpret_cast< wxWindow * >(argp1);
33604 {
33605 PyThreadState* __tstate = wxPyBeginAllowThreads();
33606 result = (PyObject *)wxWindow_GetChildren(arg1);
33607 wxPyEndAllowThreads(__tstate);
33608 if (PyErr_Occurred()) SWIG_fail;
33609 }
33610 resultobj = result;
33611 return resultobj;
33612 fail:
33613 return NULL;
33614 }
33615
33616
33617 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33618 PyObject *resultobj = 0;
33619 wxWindow *arg1 = (wxWindow *) 0 ;
33620 wxWindow *result = 0 ;
33621 void *argp1 = 0 ;
33622 int res1 = 0 ;
33623 PyObject *swig_obj[1] ;
33624
33625 if (!args) SWIG_fail;
33626 swig_obj[0] = args;
33627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33628 if (!SWIG_IsOK(res1)) {
33629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33630 }
33631 arg1 = reinterpret_cast< wxWindow * >(argp1);
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 {
33639 resultobj = wxPyMake_wxObject(result, 0);
33640 }
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33648 PyObject *resultobj = 0;
33649 wxWindow *arg1 = (wxWindow *) 0 ;
33650 wxWindow *result = 0 ;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 PyObject *swig_obj[1] ;
33654
33655 if (!args) SWIG_fail;
33656 swig_obj[0] = args;
33657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33658 if (!SWIG_IsOK(res1)) {
33659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33660 }
33661 arg1 = reinterpret_cast< wxWindow * >(argp1);
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33665 wxPyEndAllowThreads(__tstate);
33666 if (PyErr_Occurred()) SWIG_fail;
33667 }
33668 {
33669 resultobj = wxPyMake_wxObject(result, 0);
33670 }
33671 return resultobj;
33672 fail:
33673 return NULL;
33674 }
33675
33676
33677 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33678 PyObject *resultobj = 0;
33679 wxWindow *arg1 = (wxWindow *) 0 ;
33680 bool result;
33681 void *argp1 = 0 ;
33682 int res1 = 0 ;
33683 PyObject *swig_obj[1] ;
33684
33685 if (!args) SWIG_fail;
33686 swig_obj[0] = args;
33687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33690 }
33691 arg1 = reinterpret_cast< wxWindow * >(argp1);
33692 {
33693 PyThreadState* __tstate = wxPyBeginAllowThreads();
33694 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 {
33699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33700 }
33701 return resultobj;
33702 fail:
33703 return NULL;
33704 }
33705
33706
33707 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33708 PyObject *resultobj = 0;
33709 wxWindow *arg1 = (wxWindow *) 0 ;
33710 wxWindow *arg2 = (wxWindow *) 0 ;
33711 bool result;
33712 void *argp1 = 0 ;
33713 int res1 = 0 ;
33714 void *argp2 = 0 ;
33715 int res2 = 0 ;
33716 PyObject * obj0 = 0 ;
33717 PyObject * obj1 = 0 ;
33718 char * kwnames[] = {
33719 (char *) "self",(char *) "newParent", NULL
33720 };
33721
33722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33724 if (!SWIG_IsOK(res1)) {
33725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33726 }
33727 arg1 = reinterpret_cast< wxWindow * >(argp1);
33728 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33729 if (!SWIG_IsOK(res2)) {
33730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33731 }
33732 arg2 = reinterpret_cast< wxWindow * >(argp2);
33733 {
33734 PyThreadState* __tstate = wxPyBeginAllowThreads();
33735 result = (bool)(arg1)->Reparent(arg2);
33736 wxPyEndAllowThreads(__tstate);
33737 if (PyErr_Occurred()) SWIG_fail;
33738 }
33739 {
33740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33741 }
33742 return resultobj;
33743 fail:
33744 return NULL;
33745 }
33746
33747
33748 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33749 PyObject *resultobj = 0;
33750 wxWindow *arg1 = (wxWindow *) 0 ;
33751 wxWindow *arg2 = (wxWindow *) 0 ;
33752 void *argp1 = 0 ;
33753 int res1 = 0 ;
33754 void *argp2 = 0 ;
33755 int res2 = 0 ;
33756 PyObject * obj0 = 0 ;
33757 PyObject * obj1 = 0 ;
33758 char * kwnames[] = {
33759 (char *) "self",(char *) "child", NULL
33760 };
33761
33762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33764 if (!SWIG_IsOK(res1)) {
33765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33766 }
33767 arg1 = reinterpret_cast< wxWindow * >(argp1);
33768 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33769 if (!SWIG_IsOK(res2)) {
33770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33771 }
33772 arg2 = reinterpret_cast< wxWindow * >(argp2);
33773 {
33774 PyThreadState* __tstate = wxPyBeginAllowThreads();
33775 (arg1)->AddChild(arg2);
33776 wxPyEndAllowThreads(__tstate);
33777 if (PyErr_Occurred()) SWIG_fail;
33778 }
33779 resultobj = SWIG_Py_Void();
33780 return resultobj;
33781 fail:
33782 return NULL;
33783 }
33784
33785
33786 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33787 PyObject *resultobj = 0;
33788 wxWindow *arg1 = (wxWindow *) 0 ;
33789 wxWindow *arg2 = (wxWindow *) 0 ;
33790 void *argp1 = 0 ;
33791 int res1 = 0 ;
33792 void *argp2 = 0 ;
33793 int res2 = 0 ;
33794 PyObject * obj0 = 0 ;
33795 PyObject * obj1 = 0 ;
33796 char * kwnames[] = {
33797 (char *) "self",(char *) "child", NULL
33798 };
33799
33800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33802 if (!SWIG_IsOK(res1)) {
33803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33804 }
33805 arg1 = reinterpret_cast< wxWindow * >(argp1);
33806 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33807 if (!SWIG_IsOK(res2)) {
33808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33809 }
33810 arg2 = reinterpret_cast< wxWindow * >(argp2);
33811 {
33812 PyThreadState* __tstate = wxPyBeginAllowThreads();
33813 (arg1)->RemoveChild(arg2);
33814 wxPyEndAllowThreads(__tstate);
33815 if (PyErr_Occurred()) SWIG_fail;
33816 }
33817 resultobj = SWIG_Py_Void();
33818 return resultobj;
33819 fail:
33820 return NULL;
33821 }
33822
33823
33824 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33825 PyObject *resultobj = 0;
33826 wxWindow *arg1 = (wxWindow *) 0 ;
33827 bool arg2 ;
33828 void *argp1 = 0 ;
33829 int res1 = 0 ;
33830 bool val2 ;
33831 int ecode2 = 0 ;
33832 PyObject * obj0 = 0 ;
33833 PyObject * obj1 = 0 ;
33834 char * kwnames[] = {
33835 (char *) "self",(char *) "on", NULL
33836 };
33837
33838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33840 if (!SWIG_IsOK(res1)) {
33841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33842 }
33843 arg1 = reinterpret_cast< wxWindow * >(argp1);
33844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33845 if (!SWIG_IsOK(ecode2)) {
33846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33847 }
33848 arg2 = static_cast< bool >(val2);
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 wxWindow_SetDoubleBuffered(arg1,arg2);
33852 wxPyEndAllowThreads(__tstate);
33853 if (PyErr_Occurred()) SWIG_fail;
33854 }
33855 resultobj = SWIG_Py_Void();
33856 return resultobj;
33857 fail:
33858 return NULL;
33859 }
33860
33861
33862 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33863 PyObject *resultobj = 0;
33864 wxWindow *arg1 = (wxWindow *) 0 ;
33865 long arg2 ;
33866 wxWindow *result = 0 ;
33867 void *argp1 = 0 ;
33868 int res1 = 0 ;
33869 long val2 ;
33870 int ecode2 = 0 ;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 char * kwnames[] = {
33874 (char *) "self",(char *) "winid", NULL
33875 };
33876
33877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33879 if (!SWIG_IsOK(res1)) {
33880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33881 }
33882 arg1 = reinterpret_cast< wxWindow * >(argp1);
33883 ecode2 = SWIG_AsVal_long(obj1, &val2);
33884 if (!SWIG_IsOK(ecode2)) {
33885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33886 }
33887 arg2 = static_cast< long >(val2);
33888 {
33889 PyThreadState* __tstate = wxPyBeginAllowThreads();
33890 result = (wxWindow *)(arg1)->FindWindow(arg2);
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 {
33895 resultobj = wxPyMake_wxObject(result, 0);
33896 }
33897 return resultobj;
33898 fail:
33899 return NULL;
33900 }
33901
33902
33903 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33904 PyObject *resultobj = 0;
33905 wxWindow *arg1 = (wxWindow *) 0 ;
33906 wxString *arg2 = 0 ;
33907 wxWindow *result = 0 ;
33908 void *argp1 = 0 ;
33909 int res1 = 0 ;
33910 bool temp2 = false ;
33911 PyObject * obj0 = 0 ;
33912 PyObject * obj1 = 0 ;
33913 char * kwnames[] = {
33914 (char *) "self",(char *) "name", NULL
33915 };
33916
33917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",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_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33921 }
33922 arg1 = reinterpret_cast< wxWindow * >(argp1);
33923 {
33924 arg2 = wxString_in_helper(obj1);
33925 if (arg2 == NULL) SWIG_fail;
33926 temp2 = true;
33927 }
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 {
33935 resultobj = wxPyMake_wxObject(result, 0);
33936 }
33937 {
33938 if (temp2)
33939 delete arg2;
33940 }
33941 return resultobj;
33942 fail:
33943 {
33944 if (temp2)
33945 delete arg2;
33946 }
33947 return NULL;
33948 }
33949
33950
33951 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33952 PyObject *resultobj = 0;
33953 wxWindow *arg1 = (wxWindow *) 0 ;
33954 wxEvtHandler *result = 0 ;
33955 void *argp1 = 0 ;
33956 int res1 = 0 ;
33957 PyObject *swig_obj[1] ;
33958
33959 if (!args) SWIG_fail;
33960 swig_obj[0] = args;
33961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33962 if (!SWIG_IsOK(res1)) {
33963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33964 }
33965 arg1 = reinterpret_cast< wxWindow * >(argp1);
33966 {
33967 PyThreadState* __tstate = wxPyBeginAllowThreads();
33968 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33969 wxPyEndAllowThreads(__tstate);
33970 if (PyErr_Occurred()) SWIG_fail;
33971 }
33972 {
33973 resultobj = wxPyMake_wxObject(result, 0);
33974 }
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj = 0;
33983 wxWindow *arg1 = (wxWindow *) 0 ;
33984 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 void *argp2 = 0 ;
33988 int res2 = 0 ;
33989 PyObject * obj0 = 0 ;
33990 PyObject * obj1 = 0 ;
33991 char * kwnames[] = {
33992 (char *) "self",(char *) "handler", NULL
33993 };
33994
33995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33997 if (!SWIG_IsOK(res1)) {
33998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33999 }
34000 arg1 = reinterpret_cast< wxWindow * >(argp1);
34001 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34002 if (!SWIG_IsOK(res2)) {
34003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34004 }
34005 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34006 {
34007 PyThreadState* __tstate = wxPyBeginAllowThreads();
34008 (arg1)->SetEventHandler(arg2);
34009 wxPyEndAllowThreads(__tstate);
34010 if (PyErr_Occurred()) SWIG_fail;
34011 }
34012 resultobj = SWIG_Py_Void();
34013 return resultobj;
34014 fail:
34015 return NULL;
34016 }
34017
34018
34019 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34020 PyObject *resultobj = 0;
34021 wxWindow *arg1 = (wxWindow *) 0 ;
34022 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34023 void *argp1 = 0 ;
34024 int res1 = 0 ;
34025 void *argp2 = 0 ;
34026 int res2 = 0 ;
34027 PyObject * obj0 = 0 ;
34028 PyObject * obj1 = 0 ;
34029 char * kwnames[] = {
34030 (char *) "self",(char *) "handler", NULL
34031 };
34032
34033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34035 if (!SWIG_IsOK(res1)) {
34036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34037 }
34038 arg1 = reinterpret_cast< wxWindow * >(argp1);
34039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34040 if (!SWIG_IsOK(res2)) {
34041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34042 }
34043 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34044 {
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 (arg1)->PushEventHandler(arg2);
34047 wxPyEndAllowThreads(__tstate);
34048 if (PyErr_Occurred()) SWIG_fail;
34049 }
34050 resultobj = SWIG_Py_Void();
34051 return resultobj;
34052 fail:
34053 return NULL;
34054 }
34055
34056
34057 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34058 PyObject *resultobj = 0;
34059 wxWindow *arg1 = (wxWindow *) 0 ;
34060 bool arg2 = (bool) false ;
34061 wxEvtHandler *result = 0 ;
34062 void *argp1 = 0 ;
34063 int res1 = 0 ;
34064 bool val2 ;
34065 int ecode2 = 0 ;
34066 PyObject * obj0 = 0 ;
34067 PyObject * obj1 = 0 ;
34068 char * kwnames[] = {
34069 (char *) "self",(char *) "deleteHandler", NULL
34070 };
34071
34072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34074 if (!SWIG_IsOK(res1)) {
34075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34076 }
34077 arg1 = reinterpret_cast< wxWindow * >(argp1);
34078 if (obj1) {
34079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34080 if (!SWIG_IsOK(ecode2)) {
34081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34082 }
34083 arg2 = static_cast< bool >(val2);
34084 }
34085 {
34086 PyThreadState* __tstate = wxPyBeginAllowThreads();
34087 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34088 wxPyEndAllowThreads(__tstate);
34089 if (PyErr_Occurred()) SWIG_fail;
34090 }
34091 {
34092 resultobj = wxPyMake_wxObject(result, 0);
34093 }
34094 return resultobj;
34095 fail:
34096 return NULL;
34097 }
34098
34099
34100 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34101 PyObject *resultobj = 0;
34102 wxWindow *arg1 = (wxWindow *) 0 ;
34103 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34104 bool result;
34105 void *argp1 = 0 ;
34106 int res1 = 0 ;
34107 void *argp2 = 0 ;
34108 int res2 = 0 ;
34109 PyObject * obj0 = 0 ;
34110 PyObject * obj1 = 0 ;
34111 char * kwnames[] = {
34112 (char *) "self",(char *) "handler", NULL
34113 };
34114
34115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34117 if (!SWIG_IsOK(res1)) {
34118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34119 }
34120 arg1 = reinterpret_cast< wxWindow * >(argp1);
34121 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34122 if (!SWIG_IsOK(res2)) {
34123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34124 }
34125 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34126 {
34127 PyThreadState* __tstate = wxPyBeginAllowThreads();
34128 result = (bool)(arg1)->RemoveEventHandler(arg2);
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 {
34133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34134 }
34135 return resultobj;
34136 fail:
34137 return NULL;
34138 }
34139
34140
34141 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34142 PyObject *resultobj = 0;
34143 wxWindow *arg1 = (wxWindow *) 0 ;
34144 wxValidator *arg2 = 0 ;
34145 void *argp1 = 0 ;
34146 int res1 = 0 ;
34147 void *argp2 = 0 ;
34148 int res2 = 0 ;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 char * kwnames[] = {
34152 (char *) "self",(char *) "validator", NULL
34153 };
34154
34155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34157 if (!SWIG_IsOK(res1)) {
34158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34159 }
34160 arg1 = reinterpret_cast< wxWindow * >(argp1);
34161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34162 if (!SWIG_IsOK(res2)) {
34163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34164 }
34165 if (!argp2) {
34166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34167 }
34168 arg2 = reinterpret_cast< wxValidator * >(argp2);
34169 {
34170 PyThreadState* __tstate = wxPyBeginAllowThreads();
34171 (arg1)->SetValidator((wxValidator const &)*arg2);
34172 wxPyEndAllowThreads(__tstate);
34173 if (PyErr_Occurred()) SWIG_fail;
34174 }
34175 resultobj = SWIG_Py_Void();
34176 return resultobj;
34177 fail:
34178 return NULL;
34179 }
34180
34181
34182 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34183 PyObject *resultobj = 0;
34184 wxWindow *arg1 = (wxWindow *) 0 ;
34185 wxValidator *result = 0 ;
34186 void *argp1 = 0 ;
34187 int res1 = 0 ;
34188 PyObject *swig_obj[1] ;
34189
34190 if (!args) SWIG_fail;
34191 swig_obj[0] = args;
34192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34193 if (!SWIG_IsOK(res1)) {
34194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34195 }
34196 arg1 = reinterpret_cast< wxWindow * >(argp1);
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 result = (wxValidator *)(arg1)->GetValidator();
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 {
34204 resultobj = wxPyMake_wxObject(result, (bool)0);
34205 }
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34213 PyObject *resultobj = 0;
34214 wxWindow *arg1 = (wxWindow *) 0 ;
34215 bool result;
34216 void *argp1 = 0 ;
34217 int res1 = 0 ;
34218 PyObject *swig_obj[1] ;
34219
34220 if (!args) SWIG_fail;
34221 swig_obj[0] = args;
34222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34223 if (!SWIG_IsOK(res1)) {
34224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34225 }
34226 arg1 = reinterpret_cast< wxWindow * >(argp1);
34227 {
34228 PyThreadState* __tstate = wxPyBeginAllowThreads();
34229 result = (bool)(arg1)->Validate();
34230 wxPyEndAllowThreads(__tstate);
34231 if (PyErr_Occurred()) SWIG_fail;
34232 }
34233 {
34234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34235 }
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34243 PyObject *resultobj = 0;
34244 wxWindow *arg1 = (wxWindow *) 0 ;
34245 bool result;
34246 void *argp1 = 0 ;
34247 int res1 = 0 ;
34248 PyObject *swig_obj[1] ;
34249
34250 if (!args) SWIG_fail;
34251 swig_obj[0] = args;
34252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34253 if (!SWIG_IsOK(res1)) {
34254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34255 }
34256 arg1 = reinterpret_cast< wxWindow * >(argp1);
34257 {
34258 PyThreadState* __tstate = wxPyBeginAllowThreads();
34259 result = (bool)(arg1)->TransferDataToWindow();
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 {
34264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34265 }
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34273 PyObject *resultobj = 0;
34274 wxWindow *arg1 = (wxWindow *) 0 ;
34275 bool result;
34276 void *argp1 = 0 ;
34277 int res1 = 0 ;
34278 PyObject *swig_obj[1] ;
34279
34280 if (!args) SWIG_fail;
34281 swig_obj[0] = args;
34282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34283 if (!SWIG_IsOK(res1)) {
34284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34285 }
34286 arg1 = reinterpret_cast< wxWindow * >(argp1);
34287 {
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = (bool)(arg1)->TransferDataFromWindow();
34290 wxPyEndAllowThreads(__tstate);
34291 if (PyErr_Occurred()) SWIG_fail;
34292 }
34293 {
34294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34295 }
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34303 PyObject *resultobj = 0;
34304 wxWindow *arg1 = (wxWindow *) 0 ;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 PyObject *swig_obj[1] ;
34308
34309 if (!args) SWIG_fail;
34310 swig_obj[0] = args;
34311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34312 if (!SWIG_IsOK(res1)) {
34313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34314 }
34315 arg1 = reinterpret_cast< wxWindow * >(argp1);
34316 {
34317 PyThreadState* __tstate = wxPyBeginAllowThreads();
34318 (arg1)->InitDialog();
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 resultobj = SWIG_Py_Void();
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34330 PyObject *resultobj = 0;
34331 wxWindow *arg1 = (wxWindow *) 0 ;
34332 wxAcceleratorTable *arg2 = 0 ;
34333 void *argp1 = 0 ;
34334 int res1 = 0 ;
34335 void *argp2 = 0 ;
34336 int res2 = 0 ;
34337 PyObject * obj0 = 0 ;
34338 PyObject * obj1 = 0 ;
34339 char * kwnames[] = {
34340 (char *) "self",(char *) "accel", NULL
34341 };
34342
34343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34345 if (!SWIG_IsOK(res1)) {
34346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34347 }
34348 arg1 = reinterpret_cast< wxWindow * >(argp1);
34349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34350 if (!SWIG_IsOK(res2)) {
34351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34352 }
34353 if (!argp2) {
34354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34355 }
34356 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34357 {
34358 PyThreadState* __tstate = wxPyBeginAllowThreads();
34359 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34360 wxPyEndAllowThreads(__tstate);
34361 if (PyErr_Occurred()) SWIG_fail;
34362 }
34363 resultobj = SWIG_Py_Void();
34364 return resultobj;
34365 fail:
34366 return NULL;
34367 }
34368
34369
34370 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34371 PyObject *resultobj = 0;
34372 wxWindow *arg1 = (wxWindow *) 0 ;
34373 wxAcceleratorTable *result = 0 ;
34374 void *argp1 = 0 ;
34375 int res1 = 0 ;
34376 PyObject *swig_obj[1] ;
34377
34378 if (!args) SWIG_fail;
34379 swig_obj[0] = args;
34380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34381 if (!SWIG_IsOK(res1)) {
34382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34383 }
34384 arg1 = reinterpret_cast< wxWindow * >(argp1);
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34392 return resultobj;
34393 fail:
34394 return NULL;
34395 }
34396
34397
34398 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34399 PyObject *resultobj = 0;
34400 wxWindow *arg1 = (wxWindow *) 0 ;
34401 int arg2 ;
34402 int arg3 ;
34403 int arg4 ;
34404 bool result;
34405 void *argp1 = 0 ;
34406 int res1 = 0 ;
34407 int val2 ;
34408 int ecode2 = 0 ;
34409 int val3 ;
34410 int ecode3 = 0 ;
34411 int val4 ;
34412 int ecode4 = 0 ;
34413 PyObject * obj0 = 0 ;
34414 PyObject * obj1 = 0 ;
34415 PyObject * obj2 = 0 ;
34416 PyObject * obj3 = 0 ;
34417 char * kwnames[] = {
34418 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34419 };
34420
34421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34423 if (!SWIG_IsOK(res1)) {
34424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34425 }
34426 arg1 = reinterpret_cast< wxWindow * >(argp1);
34427 ecode2 = SWIG_AsVal_int(obj1, &val2);
34428 if (!SWIG_IsOK(ecode2)) {
34429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34430 }
34431 arg2 = static_cast< int >(val2);
34432 ecode3 = SWIG_AsVal_int(obj2, &val3);
34433 if (!SWIG_IsOK(ecode3)) {
34434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34435 }
34436 arg3 = static_cast< int >(val3);
34437 ecode4 = SWIG_AsVal_int(obj3, &val4);
34438 if (!SWIG_IsOK(ecode4)) {
34439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34440 }
34441 arg4 = static_cast< int >(val4);
34442 {
34443 PyThreadState* __tstate = wxPyBeginAllowThreads();
34444 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34445 wxPyEndAllowThreads(__tstate);
34446 if (PyErr_Occurred()) SWIG_fail;
34447 }
34448 {
34449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34450 }
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34458 PyObject *resultobj = 0;
34459 wxWindow *arg1 = (wxWindow *) 0 ;
34460 int arg2 ;
34461 bool result;
34462 void *argp1 = 0 ;
34463 int res1 = 0 ;
34464 int val2 ;
34465 int ecode2 = 0 ;
34466 PyObject * obj0 = 0 ;
34467 PyObject * obj1 = 0 ;
34468 char * kwnames[] = {
34469 (char *) "self",(char *) "hotkeyId", NULL
34470 };
34471
34472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34474 if (!SWIG_IsOK(res1)) {
34475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34476 }
34477 arg1 = reinterpret_cast< wxWindow * >(argp1);
34478 ecode2 = SWIG_AsVal_int(obj1, &val2);
34479 if (!SWIG_IsOK(ecode2)) {
34480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34481 }
34482 arg2 = static_cast< int >(val2);
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 {
34490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34491 }
34492 return resultobj;
34493 fail:
34494 return NULL;
34495 }
34496
34497
34498 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34499 PyObject *resultobj = 0;
34500 wxWindow *arg1 = (wxWindow *) 0 ;
34501 wxPoint *arg2 = 0 ;
34502 wxPoint result;
34503 void *argp1 = 0 ;
34504 int res1 = 0 ;
34505 wxPoint temp2 ;
34506 PyObject * obj0 = 0 ;
34507 PyObject * obj1 = 0 ;
34508 char * kwnames[] = {
34509 (char *) "self",(char *) "pt", NULL
34510 };
34511
34512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34514 if (!SWIG_IsOK(res1)) {
34515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34516 }
34517 arg1 = reinterpret_cast< wxWindow * >(argp1);
34518 {
34519 arg2 = &temp2;
34520 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34521 }
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34536 PyObject *resultobj = 0;
34537 wxWindow *arg1 = (wxWindow *) 0 ;
34538 wxSize *arg2 = 0 ;
34539 wxSize result;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 wxSize temp2 ;
34543 PyObject * obj0 = 0 ;
34544 PyObject * obj1 = 0 ;
34545 char * kwnames[] = {
34546 (char *) "self",(char *) "sz", NULL
34547 };
34548
34549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34551 if (!SWIG_IsOK(res1)) {
34552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34553 }
34554 arg1 = reinterpret_cast< wxWindow * >(argp1);
34555 {
34556 arg2 = &temp2;
34557 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34558 }
34559 {
34560 PyThreadState* __tstate = wxPyBeginAllowThreads();
34561 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34562 wxPyEndAllowThreads(__tstate);
34563 if (PyErr_Occurred()) SWIG_fail;
34564 }
34565 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34566 return resultobj;
34567 fail:
34568 return NULL;
34569 }
34570
34571
34572 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34573 PyObject *resultobj = 0;
34574 wxWindow *arg1 = (wxWindow *) 0 ;
34575 wxPoint *arg2 = 0 ;
34576 wxPoint result;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 wxPoint temp2 ;
34580 PyObject * obj0 = 0 ;
34581 PyObject * obj1 = 0 ;
34582 char * kwnames[] = {
34583 (char *) "self",(char *) "pt", NULL
34584 };
34585
34586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34588 if (!SWIG_IsOK(res1)) {
34589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34590 }
34591 arg1 = reinterpret_cast< wxWindow * >(argp1);
34592 {
34593 arg2 = &temp2;
34594 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34595 }
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 wxSize *arg2 = 0 ;
34613 wxSize result;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 wxSize temp2 ;
34617 PyObject * obj0 = 0 ;
34618 PyObject * obj1 = 0 ;
34619 char * kwnames[] = {
34620 (char *) "self",(char *) "sz", NULL
34621 };
34622
34623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34625 if (!SWIG_IsOK(res1)) {
34626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34627 }
34628 arg1 = reinterpret_cast< wxWindow * >(argp1);
34629 {
34630 arg2 = &temp2;
34631 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34632 }
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34640 return resultobj;
34641 fail:
34642 return NULL;
34643 }
34644
34645
34646 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34647 PyObject *resultobj = 0;
34648 wxWindow *arg1 = (wxWindow *) 0 ;
34649 wxPoint *arg2 = 0 ;
34650 wxPoint result;
34651 void *argp1 = 0 ;
34652 int res1 = 0 ;
34653 wxPoint temp2 ;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 char * kwnames[] = {
34657 (char *) "self",(char *) "pt", NULL
34658 };
34659
34660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34662 if (!SWIG_IsOK(res1)) {
34663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34664 }
34665 arg1 = reinterpret_cast< wxWindow * >(argp1);
34666 {
34667 arg2 = &temp2;
34668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34669 }
34670 {
34671 PyThreadState* __tstate = wxPyBeginAllowThreads();
34672 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34673 wxPyEndAllowThreads(__tstate);
34674 if (PyErr_Occurred()) SWIG_fail;
34675 }
34676 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34677 return resultobj;
34678 fail:
34679 return NULL;
34680 }
34681
34682
34683 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34684 PyObject *resultobj = 0;
34685 wxWindow *arg1 = (wxWindow *) 0 ;
34686 wxSize *arg2 = 0 ;
34687 wxSize result;
34688 void *argp1 = 0 ;
34689 int res1 = 0 ;
34690 wxSize temp2 ;
34691 PyObject * obj0 = 0 ;
34692 PyObject * obj1 = 0 ;
34693 char * kwnames[] = {
34694 (char *) "self",(char *) "sz", NULL
34695 };
34696
34697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34699 if (!SWIG_IsOK(res1)) {
34700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34701 }
34702 arg1 = reinterpret_cast< wxWindow * >(argp1);
34703 {
34704 arg2 = &temp2;
34705 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34706 }
34707 {
34708 PyThreadState* __tstate = wxPyBeginAllowThreads();
34709 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34710 wxPyEndAllowThreads(__tstate);
34711 if (PyErr_Occurred()) SWIG_fail;
34712 }
34713 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34714 return resultobj;
34715 fail:
34716 return NULL;
34717 }
34718
34719
34720 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34721 PyObject *resultobj = 0;
34722 wxWindow *arg1 = (wxWindow *) 0 ;
34723 int arg2 ;
34724 int arg3 ;
34725 void *argp1 = 0 ;
34726 int res1 = 0 ;
34727 int val2 ;
34728 int ecode2 = 0 ;
34729 int val3 ;
34730 int ecode3 = 0 ;
34731 PyObject * obj0 = 0 ;
34732 PyObject * obj1 = 0 ;
34733 PyObject * obj2 = 0 ;
34734 char * kwnames[] = {
34735 (char *) "self",(char *) "x",(char *) "y", NULL
34736 };
34737
34738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34742 }
34743 arg1 = reinterpret_cast< wxWindow * >(argp1);
34744 ecode2 = SWIG_AsVal_int(obj1, &val2);
34745 if (!SWIG_IsOK(ecode2)) {
34746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34747 }
34748 arg2 = static_cast< int >(val2);
34749 ecode3 = SWIG_AsVal_int(obj2, &val3);
34750 if (!SWIG_IsOK(ecode3)) {
34751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34752 }
34753 arg3 = static_cast< int >(val3);
34754 {
34755 PyThreadState* __tstate = wxPyBeginAllowThreads();
34756 (arg1)->WarpPointer(arg2,arg3);
34757 wxPyEndAllowThreads(__tstate);
34758 if (PyErr_Occurred()) SWIG_fail;
34759 }
34760 resultobj = SWIG_Py_Void();
34761 return resultobj;
34762 fail:
34763 return NULL;
34764 }
34765
34766
34767 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34768 PyObject *resultobj = 0;
34769 wxWindow *arg1 = (wxWindow *) 0 ;
34770 void *argp1 = 0 ;
34771 int res1 = 0 ;
34772 PyObject *swig_obj[1] ;
34773
34774 if (!args) SWIG_fail;
34775 swig_obj[0] = args;
34776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34777 if (!SWIG_IsOK(res1)) {
34778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34779 }
34780 arg1 = reinterpret_cast< wxWindow * >(argp1);
34781 {
34782 PyThreadState* __tstate = wxPyBeginAllowThreads();
34783 (arg1)->CaptureMouse();
34784 wxPyEndAllowThreads(__tstate);
34785 if (PyErr_Occurred()) SWIG_fail;
34786 }
34787 resultobj = SWIG_Py_Void();
34788 return resultobj;
34789 fail:
34790 return NULL;
34791 }
34792
34793
34794 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34795 PyObject *resultobj = 0;
34796 wxWindow *arg1 = (wxWindow *) 0 ;
34797 void *argp1 = 0 ;
34798 int res1 = 0 ;
34799 PyObject *swig_obj[1] ;
34800
34801 if (!args) SWIG_fail;
34802 swig_obj[0] = args;
34803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34804 if (!SWIG_IsOK(res1)) {
34805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34806 }
34807 arg1 = reinterpret_cast< wxWindow * >(argp1);
34808 {
34809 PyThreadState* __tstate = wxPyBeginAllowThreads();
34810 (arg1)->ReleaseMouse();
34811 wxPyEndAllowThreads(__tstate);
34812 if (PyErr_Occurred()) SWIG_fail;
34813 }
34814 resultobj = SWIG_Py_Void();
34815 return resultobj;
34816 fail:
34817 return NULL;
34818 }
34819
34820
34821 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34822 PyObject *resultobj = 0;
34823 wxWindow *result = 0 ;
34824
34825 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34826 {
34827 if (!wxPyCheckForApp()) SWIG_fail;
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 result = (wxWindow *)wxWindow::GetCapture();
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 {
34834 resultobj = wxPyMake_wxObject(result, 0);
34835 }
34836 return resultobj;
34837 fail:
34838 return NULL;
34839 }
34840
34841
34842 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34843 PyObject *resultobj = 0;
34844 wxWindow *arg1 = (wxWindow *) 0 ;
34845 bool result;
34846 void *argp1 = 0 ;
34847 int res1 = 0 ;
34848 PyObject *swig_obj[1] ;
34849
34850 if (!args) SWIG_fail;
34851 swig_obj[0] = args;
34852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34853 if (!SWIG_IsOK(res1)) {
34854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34855 }
34856 arg1 = reinterpret_cast< wxWindow * >(argp1);
34857 {
34858 PyThreadState* __tstate = wxPyBeginAllowThreads();
34859 result = (bool)((wxWindow const *)arg1)->HasCapture();
34860 wxPyEndAllowThreads(__tstate);
34861 if (PyErr_Occurred()) SWIG_fail;
34862 }
34863 {
34864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34865 }
34866 return resultobj;
34867 fail:
34868 return NULL;
34869 }
34870
34871
34872 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34873 PyObject *resultobj = 0;
34874 wxWindow *arg1 = (wxWindow *) 0 ;
34875 bool arg2 = (bool) true ;
34876 wxRect *arg3 = (wxRect *) NULL ;
34877 void *argp1 = 0 ;
34878 int res1 = 0 ;
34879 bool val2 ;
34880 int ecode2 = 0 ;
34881 void *argp3 = 0 ;
34882 int res3 = 0 ;
34883 PyObject * obj0 = 0 ;
34884 PyObject * obj1 = 0 ;
34885 PyObject * obj2 = 0 ;
34886 char * kwnames[] = {
34887 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34888 };
34889
34890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34892 if (!SWIG_IsOK(res1)) {
34893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34894 }
34895 arg1 = reinterpret_cast< wxWindow * >(argp1);
34896 if (obj1) {
34897 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34898 if (!SWIG_IsOK(ecode2)) {
34899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34900 }
34901 arg2 = static_cast< bool >(val2);
34902 }
34903 if (obj2) {
34904 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34905 if (!SWIG_IsOK(res3)) {
34906 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34907 }
34908 arg3 = reinterpret_cast< wxRect * >(argp3);
34909 }
34910 {
34911 PyThreadState* __tstate = wxPyBeginAllowThreads();
34912 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34913 wxPyEndAllowThreads(__tstate);
34914 if (PyErr_Occurred()) SWIG_fail;
34915 }
34916 resultobj = SWIG_Py_Void();
34917 return resultobj;
34918 fail:
34919 return NULL;
34920 }
34921
34922
34923 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj = 0;
34925 wxWindow *arg1 = (wxWindow *) 0 ;
34926 wxRect *arg2 = 0 ;
34927 bool arg3 = (bool) true ;
34928 void *argp1 = 0 ;
34929 int res1 = 0 ;
34930 wxRect temp2 ;
34931 bool val3 ;
34932 int ecode3 = 0 ;
34933 PyObject * obj0 = 0 ;
34934 PyObject * obj1 = 0 ;
34935 PyObject * obj2 = 0 ;
34936 char * kwnames[] = {
34937 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34938 };
34939
34940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34942 if (!SWIG_IsOK(res1)) {
34943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34944 }
34945 arg1 = reinterpret_cast< wxWindow * >(argp1);
34946 {
34947 arg2 = &temp2;
34948 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34949 }
34950 if (obj2) {
34951 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34952 if (!SWIG_IsOK(ecode3)) {
34953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34954 }
34955 arg3 = static_cast< bool >(val3);
34956 }
34957 {
34958 PyThreadState* __tstate = wxPyBeginAllowThreads();
34959 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34960 wxPyEndAllowThreads(__tstate);
34961 if (PyErr_Occurred()) SWIG_fail;
34962 }
34963 resultobj = SWIG_Py_Void();
34964 return resultobj;
34965 fail:
34966 return NULL;
34967 }
34968
34969
34970 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34971 PyObject *resultobj = 0;
34972 wxWindow *arg1 = (wxWindow *) 0 ;
34973 void *argp1 = 0 ;
34974 int res1 = 0 ;
34975 PyObject *swig_obj[1] ;
34976
34977 if (!args) SWIG_fail;
34978 swig_obj[0] = args;
34979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34980 if (!SWIG_IsOK(res1)) {
34981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34982 }
34983 arg1 = reinterpret_cast< wxWindow * >(argp1);
34984 {
34985 PyThreadState* __tstate = wxPyBeginAllowThreads();
34986 (arg1)->Update();
34987 wxPyEndAllowThreads(__tstate);
34988 if (PyErr_Occurred()) SWIG_fail;
34989 }
34990 resultobj = SWIG_Py_Void();
34991 return resultobj;
34992 fail:
34993 return NULL;
34994 }
34995
34996
34997 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34998 PyObject *resultobj = 0;
34999 wxWindow *arg1 = (wxWindow *) 0 ;
35000 void *argp1 = 0 ;
35001 int res1 = 0 ;
35002 PyObject *swig_obj[1] ;
35003
35004 if (!args) SWIG_fail;
35005 swig_obj[0] = args;
35006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35007 if (!SWIG_IsOK(res1)) {
35008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35009 }
35010 arg1 = reinterpret_cast< wxWindow * >(argp1);
35011 {
35012 PyThreadState* __tstate = wxPyBeginAllowThreads();
35013 (arg1)->ClearBackground();
35014 wxPyEndAllowThreads(__tstate);
35015 if (PyErr_Occurred()) SWIG_fail;
35016 }
35017 resultobj = SWIG_Py_Void();
35018 return resultobj;
35019 fail:
35020 return NULL;
35021 }
35022
35023
35024 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35025 PyObject *resultobj = 0;
35026 wxWindow *arg1 = (wxWindow *) 0 ;
35027 void *argp1 = 0 ;
35028 int res1 = 0 ;
35029 PyObject *swig_obj[1] ;
35030
35031 if (!args) SWIG_fail;
35032 swig_obj[0] = args;
35033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35034 if (!SWIG_IsOK(res1)) {
35035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35036 }
35037 arg1 = reinterpret_cast< wxWindow * >(argp1);
35038 {
35039 PyThreadState* __tstate = wxPyBeginAllowThreads();
35040 (arg1)->Freeze();
35041 wxPyEndAllowThreads(__tstate);
35042 if (PyErr_Occurred()) SWIG_fail;
35043 }
35044 resultobj = SWIG_Py_Void();
35045 return resultobj;
35046 fail:
35047 return NULL;
35048 }
35049
35050
35051 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35052 PyObject *resultobj = 0;
35053 wxWindow *arg1 = (wxWindow *) 0 ;
35054 bool result;
35055 void *argp1 = 0 ;
35056 int res1 = 0 ;
35057 PyObject *swig_obj[1] ;
35058
35059 if (!args) SWIG_fail;
35060 swig_obj[0] = args;
35061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35062 if (!SWIG_IsOK(res1)) {
35063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35064 }
35065 arg1 = reinterpret_cast< wxWindow * >(argp1);
35066 {
35067 PyThreadState* __tstate = wxPyBeginAllowThreads();
35068 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35069 wxPyEndAllowThreads(__tstate);
35070 if (PyErr_Occurred()) SWIG_fail;
35071 }
35072 {
35073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35074 }
35075 return resultobj;
35076 fail:
35077 return NULL;
35078 }
35079
35080
35081 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35082 PyObject *resultobj = 0;
35083 wxWindow *arg1 = (wxWindow *) 0 ;
35084 void *argp1 = 0 ;
35085 int res1 = 0 ;
35086 PyObject *swig_obj[1] ;
35087
35088 if (!args) SWIG_fail;
35089 swig_obj[0] = args;
35090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35091 if (!SWIG_IsOK(res1)) {
35092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35093 }
35094 arg1 = reinterpret_cast< wxWindow * >(argp1);
35095 {
35096 PyThreadState* __tstate = wxPyBeginAllowThreads();
35097 (arg1)->Thaw();
35098 wxPyEndAllowThreads(__tstate);
35099 if (PyErr_Occurred()) SWIG_fail;
35100 }
35101 resultobj = SWIG_Py_Void();
35102 return resultobj;
35103 fail:
35104 return NULL;
35105 }
35106
35107
35108 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35109 PyObject *resultobj = 0;
35110 wxWindow *arg1 = (wxWindow *) 0 ;
35111 wxDC *arg2 = 0 ;
35112 void *argp1 = 0 ;
35113 int res1 = 0 ;
35114 void *argp2 = 0 ;
35115 int res2 = 0 ;
35116 PyObject * obj0 = 0 ;
35117 PyObject * obj1 = 0 ;
35118 char * kwnames[] = {
35119 (char *) "self",(char *) "dc", NULL
35120 };
35121
35122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35124 if (!SWIG_IsOK(res1)) {
35125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35126 }
35127 arg1 = reinterpret_cast< wxWindow * >(argp1);
35128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35129 if (!SWIG_IsOK(res2)) {
35130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35131 }
35132 if (!argp2) {
35133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35134 }
35135 arg2 = reinterpret_cast< wxDC * >(argp2);
35136 {
35137 PyThreadState* __tstate = wxPyBeginAllowThreads();
35138 (arg1)->PrepareDC(*arg2);
35139 wxPyEndAllowThreads(__tstate);
35140 if (PyErr_Occurred()) SWIG_fail;
35141 }
35142 resultobj = SWIG_Py_Void();
35143 return resultobj;
35144 fail:
35145 return NULL;
35146 }
35147
35148
35149 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35150 PyObject *resultobj = 0;
35151 wxWindow *arg1 = (wxWindow *) 0 ;
35152 wxRegion *result = 0 ;
35153 void *argp1 = 0 ;
35154 int res1 = 0 ;
35155 PyObject *swig_obj[1] ;
35156
35157 if (!args) SWIG_fail;
35158 swig_obj[0] = args;
35159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35160 if (!SWIG_IsOK(res1)) {
35161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35162 }
35163 arg1 = reinterpret_cast< wxWindow * >(argp1);
35164 {
35165 PyThreadState* __tstate = wxPyBeginAllowThreads();
35166 {
35167 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35168 result = (wxRegion *) &_result_ref;
35169 }
35170 wxPyEndAllowThreads(__tstate);
35171 if (PyErr_Occurred()) SWIG_fail;
35172 }
35173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35174 return resultobj;
35175 fail:
35176 return NULL;
35177 }
35178
35179
35180 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35181 PyObject *resultobj = 0;
35182 wxWindow *arg1 = (wxWindow *) 0 ;
35183 wxRect result;
35184 void *argp1 = 0 ;
35185 int res1 = 0 ;
35186 PyObject *swig_obj[1] ;
35187
35188 if (!args) SWIG_fail;
35189 swig_obj[0] = args;
35190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35191 if (!SWIG_IsOK(res1)) {
35192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35193 }
35194 arg1 = reinterpret_cast< wxWindow * >(argp1);
35195 {
35196 PyThreadState* __tstate = wxPyBeginAllowThreads();
35197 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35198 wxPyEndAllowThreads(__tstate);
35199 if (PyErr_Occurred()) SWIG_fail;
35200 }
35201 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35202 return resultobj;
35203 fail:
35204 return NULL;
35205 }
35206
35207
35208 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35209 PyObject *resultobj = 0;
35210 wxWindow *arg1 = (wxWindow *) 0 ;
35211 int arg2 ;
35212 int arg3 ;
35213 int arg4 = (int) 1 ;
35214 int arg5 = (int) 1 ;
35215 bool result;
35216 void *argp1 = 0 ;
35217 int res1 = 0 ;
35218 int val2 ;
35219 int ecode2 = 0 ;
35220 int val3 ;
35221 int ecode3 = 0 ;
35222 int val4 ;
35223 int ecode4 = 0 ;
35224 int val5 ;
35225 int ecode5 = 0 ;
35226 PyObject * obj0 = 0 ;
35227 PyObject * obj1 = 0 ;
35228 PyObject * obj2 = 0 ;
35229 PyObject * obj3 = 0 ;
35230 PyObject * obj4 = 0 ;
35231 char * kwnames[] = {
35232 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35233 };
35234
35235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35239 }
35240 arg1 = reinterpret_cast< wxWindow * >(argp1);
35241 ecode2 = SWIG_AsVal_int(obj1, &val2);
35242 if (!SWIG_IsOK(ecode2)) {
35243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35244 }
35245 arg2 = static_cast< int >(val2);
35246 ecode3 = SWIG_AsVal_int(obj2, &val3);
35247 if (!SWIG_IsOK(ecode3)) {
35248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35249 }
35250 arg3 = static_cast< int >(val3);
35251 if (obj3) {
35252 ecode4 = SWIG_AsVal_int(obj3, &val4);
35253 if (!SWIG_IsOK(ecode4)) {
35254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35255 }
35256 arg4 = static_cast< int >(val4);
35257 }
35258 if (obj4) {
35259 ecode5 = SWIG_AsVal_int(obj4, &val5);
35260 if (!SWIG_IsOK(ecode5)) {
35261 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35262 }
35263 arg5 = static_cast< int >(val5);
35264 }
35265 {
35266 PyThreadState* __tstate = wxPyBeginAllowThreads();
35267 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35268 wxPyEndAllowThreads(__tstate);
35269 if (PyErr_Occurred()) SWIG_fail;
35270 }
35271 {
35272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35273 }
35274 return resultobj;
35275 fail:
35276 return NULL;
35277 }
35278
35279
35280 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35281 PyObject *resultobj = 0;
35282 wxWindow *arg1 = (wxWindow *) 0 ;
35283 wxPoint *arg2 = 0 ;
35284 bool result;
35285 void *argp1 = 0 ;
35286 int res1 = 0 ;
35287 wxPoint temp2 ;
35288 PyObject * obj0 = 0 ;
35289 PyObject * obj1 = 0 ;
35290 char * kwnames[] = {
35291 (char *) "self",(char *) "pt", NULL
35292 };
35293
35294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35296 if (!SWIG_IsOK(res1)) {
35297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35298 }
35299 arg1 = reinterpret_cast< wxWindow * >(argp1);
35300 {
35301 arg2 = &temp2;
35302 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35303 }
35304 {
35305 PyThreadState* __tstate = wxPyBeginAllowThreads();
35306 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35307 wxPyEndAllowThreads(__tstate);
35308 if (PyErr_Occurred()) SWIG_fail;
35309 }
35310 {
35311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35312 }
35313 return resultobj;
35314 fail:
35315 return NULL;
35316 }
35317
35318
35319 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35320 PyObject *resultobj = 0;
35321 wxWindow *arg1 = (wxWindow *) 0 ;
35322 wxRect *arg2 = 0 ;
35323 bool result;
35324 void *argp1 = 0 ;
35325 int res1 = 0 ;
35326 wxRect temp2 ;
35327 PyObject * obj0 = 0 ;
35328 PyObject * obj1 = 0 ;
35329 char * kwnames[] = {
35330 (char *) "self",(char *) "rect", NULL
35331 };
35332
35333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35335 if (!SWIG_IsOK(res1)) {
35336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35337 }
35338 arg1 = reinterpret_cast< wxWindow * >(argp1);
35339 {
35340 arg2 = &temp2;
35341 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35342 }
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 {
35350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35351 }
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35359 PyObject *resultobj = 0;
35360 wxWindow *arg1 = (wxWindow *) 0 ;
35361 SwigValueWrapper<wxVisualAttributes > result;
35362 void *argp1 = 0 ;
35363 int res1 = 0 ;
35364 PyObject *swig_obj[1] ;
35365
35366 if (!args) SWIG_fail;
35367 swig_obj[0] = args;
35368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35369 if (!SWIG_IsOK(res1)) {
35370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35371 }
35372 arg1 = reinterpret_cast< wxWindow * >(argp1);
35373 {
35374 PyThreadState* __tstate = wxPyBeginAllowThreads();
35375 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35376 wxPyEndAllowThreads(__tstate);
35377 if (PyErr_Occurred()) SWIG_fail;
35378 }
35379 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35380 return resultobj;
35381 fail:
35382 return NULL;
35383 }
35384
35385
35386 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35387 PyObject *resultobj = 0;
35388 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35389 SwigValueWrapper<wxVisualAttributes > result;
35390 int val1 ;
35391 int ecode1 = 0 ;
35392 PyObject * obj0 = 0 ;
35393 char * kwnames[] = {
35394 (char *) "variant", NULL
35395 };
35396
35397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35398 if (obj0) {
35399 ecode1 = SWIG_AsVal_int(obj0, &val1);
35400 if (!SWIG_IsOK(ecode1)) {
35401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35402 }
35403 arg1 = static_cast< wxWindowVariant >(val1);
35404 }
35405 {
35406 if (!wxPyCheckForApp()) SWIG_fail;
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 result = wxWindow::GetClassDefaultAttributes(arg1);
35409 wxPyEndAllowThreads(__tstate);
35410 if (PyErr_Occurred()) SWIG_fail;
35411 }
35412 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35420 PyObject *resultobj = 0;
35421 wxWindow *arg1 = (wxWindow *) 0 ;
35422 wxColour *arg2 = 0 ;
35423 bool result;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 wxColour temp2 ;
35427 PyObject * obj0 = 0 ;
35428 PyObject * obj1 = 0 ;
35429 char * kwnames[] = {
35430 (char *) "self",(char *) "colour", NULL
35431 };
35432
35433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35435 if (!SWIG_IsOK(res1)) {
35436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35437 }
35438 arg1 = reinterpret_cast< wxWindow * >(argp1);
35439 {
35440 arg2 = &temp2;
35441 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35442 }
35443 {
35444 PyThreadState* __tstate = wxPyBeginAllowThreads();
35445 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35446 wxPyEndAllowThreads(__tstate);
35447 if (PyErr_Occurred()) SWIG_fail;
35448 }
35449 {
35450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35451 }
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35459 PyObject *resultobj = 0;
35460 wxWindow *arg1 = (wxWindow *) 0 ;
35461 wxColour *arg2 = 0 ;
35462 void *argp1 = 0 ;
35463 int res1 = 0 ;
35464 wxColour temp2 ;
35465 PyObject * obj0 = 0 ;
35466 PyObject * obj1 = 0 ;
35467 char * kwnames[] = {
35468 (char *) "self",(char *) "colour", NULL
35469 };
35470
35471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35473 if (!SWIG_IsOK(res1)) {
35474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35475 }
35476 arg1 = reinterpret_cast< wxWindow * >(argp1);
35477 {
35478 arg2 = &temp2;
35479 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35480 }
35481 {
35482 PyThreadState* __tstate = wxPyBeginAllowThreads();
35483 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35484 wxPyEndAllowThreads(__tstate);
35485 if (PyErr_Occurred()) SWIG_fail;
35486 }
35487 resultobj = SWIG_Py_Void();
35488 return resultobj;
35489 fail:
35490 return NULL;
35491 }
35492
35493
35494 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35495 PyObject *resultobj = 0;
35496 wxWindow *arg1 = (wxWindow *) 0 ;
35497 wxColour *arg2 = 0 ;
35498 bool result;
35499 void *argp1 = 0 ;
35500 int res1 = 0 ;
35501 wxColour temp2 ;
35502 PyObject * obj0 = 0 ;
35503 PyObject * obj1 = 0 ;
35504 char * kwnames[] = {
35505 (char *) "self",(char *) "colour", NULL
35506 };
35507
35508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35510 if (!SWIG_IsOK(res1)) {
35511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35512 }
35513 arg1 = reinterpret_cast< wxWindow * >(argp1);
35514 {
35515 arg2 = &temp2;
35516 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35517 }
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35521 wxPyEndAllowThreads(__tstate);
35522 if (PyErr_Occurred()) SWIG_fail;
35523 }
35524 {
35525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35526 }
35527 return resultobj;
35528 fail:
35529 return NULL;
35530 }
35531
35532
35533 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35534 PyObject *resultobj = 0;
35535 wxWindow *arg1 = (wxWindow *) 0 ;
35536 wxColour *arg2 = 0 ;
35537 void *argp1 = 0 ;
35538 int res1 = 0 ;
35539 wxColour temp2 ;
35540 PyObject * obj0 = 0 ;
35541 PyObject * obj1 = 0 ;
35542 char * kwnames[] = {
35543 (char *) "self",(char *) "colour", NULL
35544 };
35545
35546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35548 if (!SWIG_IsOK(res1)) {
35549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35550 }
35551 arg1 = reinterpret_cast< wxWindow * >(argp1);
35552 {
35553 arg2 = &temp2;
35554 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35555 }
35556 {
35557 PyThreadState* __tstate = wxPyBeginAllowThreads();
35558 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35559 wxPyEndAllowThreads(__tstate);
35560 if (PyErr_Occurred()) SWIG_fail;
35561 }
35562 resultobj = SWIG_Py_Void();
35563 return resultobj;
35564 fail:
35565 return NULL;
35566 }
35567
35568
35569 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35570 PyObject *resultobj = 0;
35571 wxWindow *arg1 = (wxWindow *) 0 ;
35572 wxColour result;
35573 void *argp1 = 0 ;
35574 int res1 = 0 ;
35575 PyObject *swig_obj[1] ;
35576
35577 if (!args) SWIG_fail;
35578 swig_obj[0] = args;
35579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35580 if (!SWIG_IsOK(res1)) {
35581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35582 }
35583 arg1 = reinterpret_cast< wxWindow * >(argp1);
35584 {
35585 PyThreadState* __tstate = wxPyBeginAllowThreads();
35586 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35587 wxPyEndAllowThreads(__tstate);
35588 if (PyErr_Occurred()) SWIG_fail;
35589 }
35590 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35591 return resultobj;
35592 fail:
35593 return NULL;
35594 }
35595
35596
35597 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35598 PyObject *resultobj = 0;
35599 wxWindow *arg1 = (wxWindow *) 0 ;
35600 wxColour result;
35601 void *argp1 = 0 ;
35602 int res1 = 0 ;
35603 PyObject *swig_obj[1] ;
35604
35605 if (!args) SWIG_fail;
35606 swig_obj[0] = args;
35607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35608 if (!SWIG_IsOK(res1)) {
35609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35610 }
35611 arg1 = reinterpret_cast< wxWindow * >(argp1);
35612 {
35613 PyThreadState* __tstate = wxPyBeginAllowThreads();
35614 result = ((wxWindow const *)arg1)->GetForegroundColour();
35615 wxPyEndAllowThreads(__tstate);
35616 if (PyErr_Occurred()) SWIG_fail;
35617 }
35618 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 bool result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 PyObject *swig_obj[1] ;
35632
35633 if (!args) SWIG_fail;
35634 swig_obj[0] = args;
35635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35636 if (!SWIG_IsOK(res1)) {
35637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35638 }
35639 arg1 = reinterpret_cast< wxWindow * >(argp1);
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 {
35647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35648 }
35649 return resultobj;
35650 fail:
35651 return NULL;
35652 }
35653
35654
35655 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35656 PyObject *resultobj = 0;
35657 wxWindow *arg1 = (wxWindow *) 0 ;
35658 bool result;
35659 void *argp1 = 0 ;
35660 int res1 = 0 ;
35661 PyObject *swig_obj[1] ;
35662
35663 if (!args) SWIG_fail;
35664 swig_obj[0] = args;
35665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35666 if (!SWIG_IsOK(res1)) {
35667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35668 }
35669 arg1 = reinterpret_cast< wxWindow * >(argp1);
35670 {
35671 PyThreadState* __tstate = wxPyBeginAllowThreads();
35672 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35673 wxPyEndAllowThreads(__tstate);
35674 if (PyErr_Occurred()) SWIG_fail;
35675 }
35676 {
35677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35678 }
35679 return resultobj;
35680 fail:
35681 return NULL;
35682 }
35683
35684
35685 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35686 PyObject *resultobj = 0;
35687 wxWindow *arg1 = (wxWindow *) 0 ;
35688 wxBackgroundStyle arg2 ;
35689 bool result;
35690 void *argp1 = 0 ;
35691 int res1 = 0 ;
35692 int val2 ;
35693 int ecode2 = 0 ;
35694 PyObject * obj0 = 0 ;
35695 PyObject * obj1 = 0 ;
35696 char * kwnames[] = {
35697 (char *) "self",(char *) "style", NULL
35698 };
35699
35700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35702 if (!SWIG_IsOK(res1)) {
35703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35704 }
35705 arg1 = reinterpret_cast< wxWindow * >(argp1);
35706 ecode2 = SWIG_AsVal_int(obj1, &val2);
35707 if (!SWIG_IsOK(ecode2)) {
35708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35709 }
35710 arg2 = static_cast< wxBackgroundStyle >(val2);
35711 {
35712 PyThreadState* __tstate = wxPyBeginAllowThreads();
35713 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35714 wxPyEndAllowThreads(__tstate);
35715 if (PyErr_Occurred()) SWIG_fail;
35716 }
35717 {
35718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35719 }
35720 return resultobj;
35721 fail:
35722 return NULL;
35723 }
35724
35725
35726 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35727 PyObject *resultobj = 0;
35728 wxWindow *arg1 = (wxWindow *) 0 ;
35729 wxBackgroundStyle result;
35730 void *argp1 = 0 ;
35731 int res1 = 0 ;
35732 PyObject *swig_obj[1] ;
35733
35734 if (!args) SWIG_fail;
35735 swig_obj[0] = args;
35736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35737 if (!SWIG_IsOK(res1)) {
35738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35739 }
35740 arg1 = reinterpret_cast< wxWindow * >(argp1);
35741 {
35742 PyThreadState* __tstate = wxPyBeginAllowThreads();
35743 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35744 wxPyEndAllowThreads(__tstate);
35745 if (PyErr_Occurred()) SWIG_fail;
35746 }
35747 resultobj = SWIG_From_int(static_cast< int >(result));
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35755 PyObject *resultobj = 0;
35756 wxWindow *arg1 = (wxWindow *) 0 ;
35757 bool result;
35758 void *argp1 = 0 ;
35759 int res1 = 0 ;
35760 PyObject *swig_obj[1] ;
35761
35762 if (!args) SWIG_fail;
35763 swig_obj[0] = args;
35764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35765 if (!SWIG_IsOK(res1)) {
35766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35767 }
35768 arg1 = reinterpret_cast< wxWindow * >(argp1);
35769 {
35770 PyThreadState* __tstate = wxPyBeginAllowThreads();
35771 result = (bool)(arg1)->HasTransparentBackground();
35772 wxPyEndAllowThreads(__tstate);
35773 if (PyErr_Occurred()) SWIG_fail;
35774 }
35775 {
35776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35777 }
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35785 PyObject *resultobj = 0;
35786 wxWindow *arg1 = (wxWindow *) 0 ;
35787 wxCursor *arg2 = 0 ;
35788 bool result;
35789 void *argp1 = 0 ;
35790 int res1 = 0 ;
35791 void *argp2 = 0 ;
35792 int res2 = 0 ;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 char * kwnames[] = {
35796 (char *) "self",(char *) "cursor", NULL
35797 };
35798
35799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35803 }
35804 arg1 = reinterpret_cast< wxWindow * >(argp1);
35805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35806 if (!SWIG_IsOK(res2)) {
35807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35808 }
35809 if (!argp2) {
35810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35811 }
35812 arg2 = reinterpret_cast< wxCursor * >(argp2);
35813 {
35814 PyThreadState* __tstate = wxPyBeginAllowThreads();
35815 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35816 wxPyEndAllowThreads(__tstate);
35817 if (PyErr_Occurred()) SWIG_fail;
35818 }
35819 {
35820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35821 }
35822 return resultobj;
35823 fail:
35824 return NULL;
35825 }
35826
35827
35828 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35829 PyObject *resultobj = 0;
35830 wxWindow *arg1 = (wxWindow *) 0 ;
35831 wxCursor result;
35832 void *argp1 = 0 ;
35833 int res1 = 0 ;
35834 PyObject *swig_obj[1] ;
35835
35836 if (!args) SWIG_fail;
35837 swig_obj[0] = args;
35838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35839 if (!SWIG_IsOK(res1)) {
35840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35841 }
35842 arg1 = reinterpret_cast< wxWindow * >(argp1);
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = (arg1)->GetCursor();
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 wxFont *arg2 = 0 ;
35860 bool result;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 void *argp2 = 0 ;
35864 int res2 = 0 ;
35865 PyObject * obj0 = 0 ;
35866 PyObject * obj1 = 0 ;
35867 char * kwnames[] = {
35868 (char *) "self",(char *) "font", NULL
35869 };
35870
35871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35873 if (!SWIG_IsOK(res1)) {
35874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35875 }
35876 arg1 = reinterpret_cast< wxWindow * >(argp1);
35877 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35878 if (!SWIG_IsOK(res2)) {
35879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35880 }
35881 if (!argp2) {
35882 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35883 }
35884 arg2 = reinterpret_cast< wxFont * >(argp2);
35885 {
35886 PyThreadState* __tstate = wxPyBeginAllowThreads();
35887 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35888 wxPyEndAllowThreads(__tstate);
35889 if (PyErr_Occurred()) SWIG_fail;
35890 }
35891 {
35892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35893 }
35894 return resultobj;
35895 fail:
35896 return NULL;
35897 }
35898
35899
35900 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35901 PyObject *resultobj = 0;
35902 wxWindow *arg1 = (wxWindow *) 0 ;
35903 wxFont *arg2 = 0 ;
35904 void *argp1 = 0 ;
35905 int res1 = 0 ;
35906 void *argp2 = 0 ;
35907 int res2 = 0 ;
35908 PyObject * obj0 = 0 ;
35909 PyObject * obj1 = 0 ;
35910 char * kwnames[] = {
35911 (char *) "self",(char *) "font", NULL
35912 };
35913
35914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35916 if (!SWIG_IsOK(res1)) {
35917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35918 }
35919 arg1 = reinterpret_cast< wxWindow * >(argp1);
35920 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35921 if (!SWIG_IsOK(res2)) {
35922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35923 }
35924 if (!argp2) {
35925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35926 }
35927 arg2 = reinterpret_cast< wxFont * >(argp2);
35928 {
35929 PyThreadState* __tstate = wxPyBeginAllowThreads();
35930 (arg1)->SetOwnFont((wxFont const &)*arg2);
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 resultobj = SWIG_Py_Void();
35935 return resultobj;
35936 fail:
35937 return NULL;
35938 }
35939
35940
35941 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35942 PyObject *resultobj = 0;
35943 wxWindow *arg1 = (wxWindow *) 0 ;
35944 wxFont result;
35945 void *argp1 = 0 ;
35946 int res1 = 0 ;
35947 PyObject *swig_obj[1] ;
35948
35949 if (!args) SWIG_fail;
35950 swig_obj[0] = args;
35951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35952 if (!SWIG_IsOK(res1)) {
35953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35954 }
35955 arg1 = reinterpret_cast< wxWindow * >(argp1);
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 result = (arg1)->GetFont();
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35963 return resultobj;
35964 fail:
35965 return NULL;
35966 }
35967
35968
35969 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35970 PyObject *resultobj = 0;
35971 wxWindow *arg1 = (wxWindow *) 0 ;
35972 wxCaret *arg2 = (wxCaret *) 0 ;
35973 void *argp1 = 0 ;
35974 int res1 = 0 ;
35975 int res2 = 0 ;
35976 PyObject * obj0 = 0 ;
35977 PyObject * obj1 = 0 ;
35978 char * kwnames[] = {
35979 (char *) "self",(char *) "caret", NULL
35980 };
35981
35982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35984 if (!SWIG_IsOK(res1)) {
35985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35986 }
35987 arg1 = reinterpret_cast< wxWindow * >(argp1);
35988 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35989 if (!SWIG_IsOK(res2)) {
35990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35991 }
35992 {
35993 PyThreadState* __tstate = wxPyBeginAllowThreads();
35994 (arg1)->SetCaret(arg2);
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 resultobj = SWIG_Py_Void();
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36006 PyObject *resultobj = 0;
36007 wxWindow *arg1 = (wxWindow *) 0 ;
36008 wxCaret *result = 0 ;
36009 void *argp1 = 0 ;
36010 int res1 = 0 ;
36011 PyObject *swig_obj[1] ;
36012
36013 if (!args) SWIG_fail;
36014 swig_obj[0] = args;
36015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36016 if (!SWIG_IsOK(res1)) {
36017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36018 }
36019 arg1 = reinterpret_cast< wxWindow * >(argp1);
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxWindow *arg1 = (wxWindow *) 0 ;
36036 int result;
36037 void *argp1 = 0 ;
36038 int res1 = 0 ;
36039 PyObject *swig_obj[1] ;
36040
36041 if (!args) SWIG_fail;
36042 swig_obj[0] = args;
36043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36044 if (!SWIG_IsOK(res1)) {
36045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36046 }
36047 arg1 = reinterpret_cast< wxWindow * >(argp1);
36048 {
36049 PyThreadState* __tstate = wxPyBeginAllowThreads();
36050 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36051 wxPyEndAllowThreads(__tstate);
36052 if (PyErr_Occurred()) SWIG_fail;
36053 }
36054 resultobj = SWIG_From_int(static_cast< int >(result));
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36062 PyObject *resultobj = 0;
36063 wxWindow *arg1 = (wxWindow *) 0 ;
36064 int result;
36065 void *argp1 = 0 ;
36066 int res1 = 0 ;
36067 PyObject *swig_obj[1] ;
36068
36069 if (!args) SWIG_fail;
36070 swig_obj[0] = args;
36071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36072 if (!SWIG_IsOK(res1)) {
36073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36074 }
36075 arg1 = reinterpret_cast< wxWindow * >(argp1);
36076 {
36077 PyThreadState* __tstate = wxPyBeginAllowThreads();
36078 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36079 wxPyEndAllowThreads(__tstate);
36080 if (PyErr_Occurred()) SWIG_fail;
36081 }
36082 resultobj = SWIG_From_int(static_cast< int >(result));
36083 return resultobj;
36084 fail:
36085 return NULL;
36086 }
36087
36088
36089 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36090 PyObject *resultobj = 0;
36091 wxWindow *arg1 = (wxWindow *) 0 ;
36092 wxString *arg2 = 0 ;
36093 int *arg3 = (int *) 0 ;
36094 int *arg4 = (int *) 0 ;
36095 void *argp1 = 0 ;
36096 int res1 = 0 ;
36097 bool temp2 = false ;
36098 int temp3 ;
36099 int res3 = SWIG_TMPOBJ ;
36100 int temp4 ;
36101 int res4 = SWIG_TMPOBJ ;
36102 PyObject * obj0 = 0 ;
36103 PyObject * obj1 = 0 ;
36104 char * kwnames[] = {
36105 (char *) "self",(char *) "string", NULL
36106 };
36107
36108 arg3 = &temp3;
36109 arg4 = &temp4;
36110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36112 if (!SWIG_IsOK(res1)) {
36113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36114 }
36115 arg1 = reinterpret_cast< wxWindow * >(argp1);
36116 {
36117 arg2 = wxString_in_helper(obj1);
36118 if (arg2 == NULL) SWIG_fail;
36119 temp2 = true;
36120 }
36121 {
36122 PyThreadState* __tstate = wxPyBeginAllowThreads();
36123 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36124 wxPyEndAllowThreads(__tstate);
36125 if (PyErr_Occurred()) SWIG_fail;
36126 }
36127 resultobj = SWIG_Py_Void();
36128 if (SWIG_IsTmpObj(res3)) {
36129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36130 } else {
36131 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36133 }
36134 if (SWIG_IsTmpObj(res4)) {
36135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36136 } else {
36137 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36139 }
36140 {
36141 if (temp2)
36142 delete arg2;
36143 }
36144 return resultobj;
36145 fail:
36146 {
36147 if (temp2)
36148 delete arg2;
36149 }
36150 return NULL;
36151 }
36152
36153
36154 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36155 PyObject *resultobj = 0;
36156 wxWindow *arg1 = (wxWindow *) 0 ;
36157 wxString *arg2 = 0 ;
36158 int *arg3 = (int *) 0 ;
36159 int *arg4 = (int *) 0 ;
36160 int *arg5 = (int *) 0 ;
36161 int *arg6 = (int *) 0 ;
36162 wxFont *arg7 = (wxFont *) NULL ;
36163 void *argp1 = 0 ;
36164 int res1 = 0 ;
36165 bool temp2 = false ;
36166 int temp3 ;
36167 int res3 = SWIG_TMPOBJ ;
36168 int temp4 ;
36169 int res4 = SWIG_TMPOBJ ;
36170 int temp5 ;
36171 int res5 = SWIG_TMPOBJ ;
36172 int temp6 ;
36173 int res6 = SWIG_TMPOBJ ;
36174 void *argp7 = 0 ;
36175 int res7 = 0 ;
36176 PyObject * obj0 = 0 ;
36177 PyObject * obj1 = 0 ;
36178 PyObject * obj2 = 0 ;
36179 char * kwnames[] = {
36180 (char *) "self",(char *) "string",(char *) "font", NULL
36181 };
36182
36183 arg3 = &temp3;
36184 arg4 = &temp4;
36185 arg5 = &temp5;
36186 arg6 = &temp6;
36187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36189 if (!SWIG_IsOK(res1)) {
36190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36191 }
36192 arg1 = reinterpret_cast< wxWindow * >(argp1);
36193 {
36194 arg2 = wxString_in_helper(obj1);
36195 if (arg2 == NULL) SWIG_fail;
36196 temp2 = true;
36197 }
36198 if (obj2) {
36199 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36200 if (!SWIG_IsOK(res7)) {
36201 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36202 }
36203 arg7 = reinterpret_cast< wxFont * >(argp7);
36204 }
36205 {
36206 PyThreadState* __tstate = wxPyBeginAllowThreads();
36207 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36208 wxPyEndAllowThreads(__tstate);
36209 if (PyErr_Occurred()) SWIG_fail;
36210 }
36211 resultobj = SWIG_Py_Void();
36212 if (SWIG_IsTmpObj(res3)) {
36213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36214 } else {
36215 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36217 }
36218 if (SWIG_IsTmpObj(res4)) {
36219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36220 } else {
36221 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36223 }
36224 if (SWIG_IsTmpObj(res5)) {
36225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36226 } else {
36227 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36229 }
36230 if (SWIG_IsTmpObj(res6)) {
36231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36232 } else {
36233 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36235 }
36236 {
36237 if (temp2)
36238 delete arg2;
36239 }
36240 return resultobj;
36241 fail:
36242 {
36243 if (temp2)
36244 delete arg2;
36245 }
36246 return NULL;
36247 }
36248
36249
36250 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36251 PyObject *resultobj = 0;
36252 wxWindow *arg1 = (wxWindow *) 0 ;
36253 int *arg2 = (int *) 0 ;
36254 int *arg3 = (int *) 0 ;
36255 void *argp1 = 0 ;
36256 int res1 = 0 ;
36257 int temp2 ;
36258 int res2 = 0 ;
36259 int temp3 ;
36260 int res3 = 0 ;
36261 PyObject * obj0 = 0 ;
36262 PyObject * obj1 = 0 ;
36263 PyObject * obj2 = 0 ;
36264 char * kwnames[] = {
36265 (char *) "self",(char *) "x",(char *) "y", NULL
36266 };
36267
36268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36270 if (!SWIG_IsOK(res1)) {
36271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36272 }
36273 arg1 = reinterpret_cast< wxWindow * >(argp1);
36274 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36275 int val;
36276 int ecode = SWIG_AsVal_int(obj1, &val);
36277 if (!SWIG_IsOK(ecode)) {
36278 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36279 }
36280 temp2 = static_cast< int >(val);
36281 arg2 = &temp2;
36282 res2 = SWIG_AddTmpMask(ecode);
36283 }
36284 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36285 int val;
36286 int ecode = SWIG_AsVal_int(obj2, &val);
36287 if (!SWIG_IsOK(ecode)) {
36288 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36289 }
36290 temp3 = static_cast< int >(val);
36291 arg3 = &temp3;
36292 res3 = SWIG_AddTmpMask(ecode);
36293 }
36294 {
36295 PyThreadState* __tstate = wxPyBeginAllowThreads();
36296 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 resultobj = SWIG_Py_Void();
36301 if (SWIG_IsTmpObj(res2)) {
36302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36303 } else {
36304 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36306 }
36307 if (SWIG_IsTmpObj(res3)) {
36308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36309 } else {
36310 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36312 }
36313 return resultobj;
36314 fail:
36315 return NULL;
36316 }
36317
36318
36319 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36320 PyObject *resultobj = 0;
36321 wxWindow *arg1 = (wxWindow *) 0 ;
36322 int *arg2 = (int *) 0 ;
36323 int *arg3 = (int *) 0 ;
36324 void *argp1 = 0 ;
36325 int res1 = 0 ;
36326 int temp2 ;
36327 int res2 = 0 ;
36328 int temp3 ;
36329 int res3 = 0 ;
36330 PyObject * obj0 = 0 ;
36331 PyObject * obj1 = 0 ;
36332 PyObject * obj2 = 0 ;
36333 char * kwnames[] = {
36334 (char *) "self",(char *) "x",(char *) "y", NULL
36335 };
36336
36337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36341 }
36342 arg1 = reinterpret_cast< wxWindow * >(argp1);
36343 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36344 int val;
36345 int ecode = SWIG_AsVal_int(obj1, &val);
36346 if (!SWIG_IsOK(ecode)) {
36347 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36348 }
36349 temp2 = static_cast< int >(val);
36350 arg2 = &temp2;
36351 res2 = SWIG_AddTmpMask(ecode);
36352 }
36353 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36354 int val;
36355 int ecode = SWIG_AsVal_int(obj2, &val);
36356 if (!SWIG_IsOK(ecode)) {
36357 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36358 }
36359 temp3 = static_cast< int >(val);
36360 arg3 = &temp3;
36361 res3 = SWIG_AddTmpMask(ecode);
36362 }
36363 {
36364 PyThreadState* __tstate = wxPyBeginAllowThreads();
36365 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36366 wxPyEndAllowThreads(__tstate);
36367 if (PyErr_Occurred()) SWIG_fail;
36368 }
36369 resultobj = SWIG_Py_Void();
36370 if (SWIG_IsTmpObj(res2)) {
36371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36372 } else {
36373 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36375 }
36376 if (SWIG_IsTmpObj(res3)) {
36377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36378 } else {
36379 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36381 }
36382 return resultobj;
36383 fail:
36384 return NULL;
36385 }
36386
36387
36388 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36389 PyObject *resultobj = 0;
36390 wxWindow *arg1 = (wxWindow *) 0 ;
36391 wxPoint *arg2 = 0 ;
36392 wxPoint result;
36393 void *argp1 = 0 ;
36394 int res1 = 0 ;
36395 wxPoint temp2 ;
36396 PyObject * obj0 = 0 ;
36397 PyObject * obj1 = 0 ;
36398 char * kwnames[] = {
36399 (char *) "self",(char *) "pt", NULL
36400 };
36401
36402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36404 if (!SWIG_IsOK(res1)) {
36405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36406 }
36407 arg1 = reinterpret_cast< wxWindow * >(argp1);
36408 {
36409 arg2 = &temp2;
36410 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36411 }
36412 {
36413 PyThreadState* __tstate = wxPyBeginAllowThreads();
36414 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36415 wxPyEndAllowThreads(__tstate);
36416 if (PyErr_Occurred()) SWIG_fail;
36417 }
36418 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36419 return resultobj;
36420 fail:
36421 return NULL;
36422 }
36423
36424
36425 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36426 PyObject *resultobj = 0;
36427 wxWindow *arg1 = (wxWindow *) 0 ;
36428 wxPoint *arg2 = 0 ;
36429 wxPoint result;
36430 void *argp1 = 0 ;
36431 int res1 = 0 ;
36432 wxPoint temp2 ;
36433 PyObject * obj0 = 0 ;
36434 PyObject * obj1 = 0 ;
36435 char * kwnames[] = {
36436 (char *) "self",(char *) "pt", NULL
36437 };
36438
36439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36441 if (!SWIG_IsOK(res1)) {
36442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36443 }
36444 arg1 = reinterpret_cast< wxWindow * >(argp1);
36445 {
36446 arg2 = &temp2;
36447 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36448 }
36449 {
36450 PyThreadState* __tstate = wxPyBeginAllowThreads();
36451 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36452 wxPyEndAllowThreads(__tstate);
36453 if (PyErr_Occurred()) SWIG_fail;
36454 }
36455 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36456 return resultobj;
36457 fail:
36458 return NULL;
36459 }
36460
36461
36462 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36463 PyObject *resultobj = 0;
36464 wxWindow *arg1 = (wxWindow *) 0 ;
36465 int arg2 ;
36466 int arg3 ;
36467 wxHitTest result;
36468 void *argp1 = 0 ;
36469 int res1 = 0 ;
36470 int val2 ;
36471 int ecode2 = 0 ;
36472 int val3 ;
36473 int ecode3 = 0 ;
36474 PyObject * obj0 = 0 ;
36475 PyObject * obj1 = 0 ;
36476 PyObject * obj2 = 0 ;
36477 char * kwnames[] = {
36478 (char *) "self",(char *) "x",(char *) "y", NULL
36479 };
36480
36481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36483 if (!SWIG_IsOK(res1)) {
36484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36485 }
36486 arg1 = reinterpret_cast< wxWindow * >(argp1);
36487 ecode2 = SWIG_AsVal_int(obj1, &val2);
36488 if (!SWIG_IsOK(ecode2)) {
36489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36490 }
36491 arg2 = static_cast< int >(val2);
36492 ecode3 = SWIG_AsVal_int(obj2, &val3);
36493 if (!SWIG_IsOK(ecode3)) {
36494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36495 }
36496 arg3 = static_cast< int >(val3);
36497 {
36498 PyThreadState* __tstate = wxPyBeginAllowThreads();
36499 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36500 wxPyEndAllowThreads(__tstate);
36501 if (PyErr_Occurred()) SWIG_fail;
36502 }
36503 resultobj = SWIG_From_int(static_cast< int >(result));
36504 return resultobj;
36505 fail:
36506 return NULL;
36507 }
36508
36509
36510 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36511 PyObject *resultobj = 0;
36512 wxWindow *arg1 = (wxWindow *) 0 ;
36513 wxPoint *arg2 = 0 ;
36514 wxHitTest result;
36515 void *argp1 = 0 ;
36516 int res1 = 0 ;
36517 wxPoint temp2 ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char * kwnames[] = {
36521 (char *) "self",(char *) "pt", NULL
36522 };
36523
36524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36526 if (!SWIG_IsOK(res1)) {
36527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36528 }
36529 arg1 = reinterpret_cast< wxWindow * >(argp1);
36530 {
36531 arg2 = &temp2;
36532 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36533 }
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 resultobj = SWIG_From_int(static_cast< int >(result));
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36548 PyObject *resultobj = 0;
36549 wxWindow *arg1 = (wxWindow *) 0 ;
36550 long arg2 ;
36551 wxBorder result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 long val2 ;
36555 int ecode2 = 0 ;
36556
36557 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36561 }
36562 arg1 = reinterpret_cast< wxWindow * >(argp1);
36563 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36564 if (!SWIG_IsOK(ecode2)) {
36565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36566 }
36567 arg2 = static_cast< long >(val2);
36568 {
36569 PyThreadState* __tstate = wxPyBeginAllowThreads();
36570 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 resultobj = SWIG_From_int(static_cast< int >(result));
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36582 PyObject *resultobj = 0;
36583 wxWindow *arg1 = (wxWindow *) 0 ;
36584 wxBorder result;
36585 void *argp1 = 0 ;
36586 int res1 = 0 ;
36587
36588 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36592 }
36593 arg1 = reinterpret_cast< wxWindow * >(argp1);
36594 {
36595 PyThreadState* __tstate = wxPyBeginAllowThreads();
36596 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 resultobj = SWIG_From_int(static_cast< int >(result));
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36608 int argc;
36609 PyObject *argv[3];
36610
36611 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36612 --argc;
36613 if (argc == 1) {
36614 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36615 }
36616 if (argc == 2) {
36617 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36618 }
36619
36620 fail:
36621 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36622 return NULL;
36623 }
36624
36625
36626 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36627 PyObject *resultobj = 0;
36628 wxWindow *arg1 = (wxWindow *) 0 ;
36629 long arg2 = (long) wxUPDATE_UI_NONE ;
36630 void *argp1 = 0 ;
36631 int res1 = 0 ;
36632 long val2 ;
36633 int ecode2 = 0 ;
36634 PyObject * obj0 = 0 ;
36635 PyObject * obj1 = 0 ;
36636 char * kwnames[] = {
36637 (char *) "self",(char *) "flags", NULL
36638 };
36639
36640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36642 if (!SWIG_IsOK(res1)) {
36643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36644 }
36645 arg1 = reinterpret_cast< wxWindow * >(argp1);
36646 if (obj1) {
36647 ecode2 = SWIG_AsVal_long(obj1, &val2);
36648 if (!SWIG_IsOK(ecode2)) {
36649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36650 }
36651 arg2 = static_cast< long >(val2);
36652 }
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 (arg1)->UpdateWindowUI(arg2);
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 resultobj = SWIG_Py_Void();
36660 return resultobj;
36661 fail:
36662 return NULL;
36663 }
36664
36665
36666 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36667 PyObject *resultobj = 0;
36668 wxWindow *arg1 = (wxWindow *) 0 ;
36669 wxMenu *arg2 = (wxMenu *) 0 ;
36670 int arg3 = (int) -1 ;
36671 int arg4 = (int) -1 ;
36672 bool result;
36673 void *argp1 = 0 ;
36674 int res1 = 0 ;
36675 void *argp2 = 0 ;
36676 int res2 = 0 ;
36677 int val3 ;
36678 int ecode3 = 0 ;
36679 int val4 ;
36680 int ecode4 = 0 ;
36681 PyObject * obj0 = 0 ;
36682 PyObject * obj1 = 0 ;
36683 PyObject * obj2 = 0 ;
36684 PyObject * obj3 = 0 ;
36685 char * kwnames[] = {
36686 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36687 };
36688
36689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36691 if (!SWIG_IsOK(res1)) {
36692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36693 }
36694 arg1 = reinterpret_cast< wxWindow * >(argp1);
36695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36696 if (!SWIG_IsOK(res2)) {
36697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36698 }
36699 arg2 = reinterpret_cast< wxMenu * >(argp2);
36700 if (obj2) {
36701 ecode3 = SWIG_AsVal_int(obj2, &val3);
36702 if (!SWIG_IsOK(ecode3)) {
36703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36704 }
36705 arg3 = static_cast< int >(val3);
36706 }
36707 if (obj3) {
36708 ecode4 = SWIG_AsVal_int(obj3, &val4);
36709 if (!SWIG_IsOK(ecode4)) {
36710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36711 }
36712 arg4 = static_cast< int >(val4);
36713 }
36714 {
36715 PyThreadState* __tstate = wxPyBeginAllowThreads();
36716 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36717 wxPyEndAllowThreads(__tstate);
36718 if (PyErr_Occurred()) SWIG_fail;
36719 }
36720 {
36721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36722 }
36723 return resultobj;
36724 fail:
36725 return NULL;
36726 }
36727
36728
36729 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36730 PyObject *resultobj = 0;
36731 wxWindow *arg1 = (wxWindow *) 0 ;
36732 wxMenu *arg2 = (wxMenu *) 0 ;
36733 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36734 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36735 bool result;
36736 void *argp1 = 0 ;
36737 int res1 = 0 ;
36738 void *argp2 = 0 ;
36739 int res2 = 0 ;
36740 wxPoint temp3 ;
36741 PyObject * obj0 = 0 ;
36742 PyObject * obj1 = 0 ;
36743 PyObject * obj2 = 0 ;
36744 char * kwnames[] = {
36745 (char *) "self",(char *) "menu",(char *) "pos", NULL
36746 };
36747
36748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36750 if (!SWIG_IsOK(res1)) {
36751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36752 }
36753 arg1 = reinterpret_cast< wxWindow * >(argp1);
36754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36755 if (!SWIG_IsOK(res2)) {
36756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36757 }
36758 arg2 = reinterpret_cast< wxMenu * >(argp2);
36759 if (obj2) {
36760 {
36761 arg3 = &temp3;
36762 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36763 }
36764 }
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36768 wxPyEndAllowThreads(__tstate);
36769 if (PyErr_Occurred()) SWIG_fail;
36770 }
36771 {
36772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36773 }
36774 return resultobj;
36775 fail:
36776 return NULL;
36777 }
36778
36779
36780 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36781 PyObject *resultobj = 0;
36782 wxWindow *arg1 = (wxWindow *) 0 ;
36783 bool result;
36784 void *argp1 = 0 ;
36785 int res1 = 0 ;
36786 PyObject *swig_obj[1] ;
36787
36788 if (!args) SWIG_fail;
36789 swig_obj[0] = args;
36790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36791 if (!SWIG_IsOK(res1)) {
36792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36793 }
36794 arg1 = reinterpret_cast< wxWindow * >(argp1);
36795 {
36796 PyThreadState* __tstate = wxPyBeginAllowThreads();
36797 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36798 wxPyEndAllowThreads(__tstate);
36799 if (PyErr_Occurred()) SWIG_fail;
36800 }
36801 {
36802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36803 }
36804 return resultobj;
36805 fail:
36806 return NULL;
36807 }
36808
36809
36810 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36811 PyObject *resultobj = 0;
36812 wxWindow *arg1 = (wxWindow *) 0 ;
36813 long result;
36814 void *argp1 = 0 ;
36815 int res1 = 0 ;
36816 PyObject *swig_obj[1] ;
36817
36818 if (!args) SWIG_fail;
36819 swig_obj[0] = args;
36820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36821 if (!SWIG_IsOK(res1)) {
36822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36823 }
36824 arg1 = reinterpret_cast< wxWindow * >(argp1);
36825 {
36826 PyThreadState* __tstate = wxPyBeginAllowThreads();
36827 result = (long)wxWindow_GetHandle(arg1);
36828 wxPyEndAllowThreads(__tstate);
36829 if (PyErr_Occurred()) SWIG_fail;
36830 }
36831 resultobj = SWIG_From_long(static_cast< long >(result));
36832 return resultobj;
36833 fail:
36834 return NULL;
36835 }
36836
36837
36838 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36839 PyObject *resultobj = 0;
36840 wxWindow *arg1 = (wxWindow *) 0 ;
36841 long arg2 ;
36842 void *argp1 = 0 ;
36843 int res1 = 0 ;
36844 long val2 ;
36845 int ecode2 = 0 ;
36846 PyObject * obj0 = 0 ;
36847 PyObject * obj1 = 0 ;
36848 char * kwnames[] = {
36849 (char *) "self",(char *) "handle", NULL
36850 };
36851
36852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36854 if (!SWIG_IsOK(res1)) {
36855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36856 }
36857 arg1 = reinterpret_cast< wxWindow * >(argp1);
36858 ecode2 = SWIG_AsVal_long(obj1, &val2);
36859 if (!SWIG_IsOK(ecode2)) {
36860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36861 }
36862 arg2 = static_cast< long >(val2);
36863 {
36864 PyThreadState* __tstate = wxPyBeginAllowThreads();
36865 wxWindow_AssociateHandle(arg1,arg2);
36866 wxPyEndAllowThreads(__tstate);
36867 if (PyErr_Occurred()) SWIG_fail;
36868 }
36869 resultobj = SWIG_Py_Void();
36870 return resultobj;
36871 fail:
36872 return NULL;
36873 }
36874
36875
36876 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36877 PyObject *resultobj = 0;
36878 wxWindow *arg1 = (wxWindow *) 0 ;
36879 void *argp1 = 0 ;
36880 int res1 = 0 ;
36881 PyObject *swig_obj[1] ;
36882
36883 if (!args) SWIG_fail;
36884 swig_obj[0] = args;
36885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36886 if (!SWIG_IsOK(res1)) {
36887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36888 }
36889 arg1 = reinterpret_cast< wxWindow * >(argp1);
36890 {
36891 PyThreadState* __tstate = wxPyBeginAllowThreads();
36892 (arg1)->DissociateHandle();
36893 wxPyEndAllowThreads(__tstate);
36894 if (PyErr_Occurred()) SWIG_fail;
36895 }
36896 resultobj = SWIG_Py_Void();
36897 return resultobj;
36898 fail:
36899 return NULL;
36900 }
36901
36902
36903 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36904 PyObject *resultobj = 0;
36905 wxWindow *arg1 = (wxWindow *) 0 ;
36906 wxPaintEvent *arg2 = 0 ;
36907 void *argp1 = 0 ;
36908 int res1 = 0 ;
36909 void *argp2 = 0 ;
36910 int res2 = 0 ;
36911 PyObject * obj0 = 0 ;
36912 PyObject * obj1 = 0 ;
36913 char * kwnames[] = {
36914 (char *) "self",(char *) "event", NULL
36915 };
36916
36917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36919 if (!SWIG_IsOK(res1)) {
36920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36921 }
36922 arg1 = reinterpret_cast< wxWindow * >(argp1);
36923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36924 if (!SWIG_IsOK(res2)) {
36925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36926 }
36927 if (!argp2) {
36928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36929 }
36930 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36931 {
36932 PyThreadState* __tstate = wxPyBeginAllowThreads();
36933 (arg1)->OnPaint(*arg2);
36934 wxPyEndAllowThreads(__tstate);
36935 if (PyErr_Occurred()) SWIG_fail;
36936 }
36937 resultobj = SWIG_Py_Void();
36938 return resultobj;
36939 fail:
36940 return NULL;
36941 }
36942
36943
36944 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36945 PyObject *resultobj = 0;
36946 wxWindow *arg1 = (wxWindow *) 0 ;
36947 int arg2 ;
36948 bool result;
36949 void *argp1 = 0 ;
36950 int res1 = 0 ;
36951 int val2 ;
36952 int ecode2 = 0 ;
36953 PyObject * obj0 = 0 ;
36954 PyObject * obj1 = 0 ;
36955 char * kwnames[] = {
36956 (char *) "self",(char *) "orient", NULL
36957 };
36958
36959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36961 if (!SWIG_IsOK(res1)) {
36962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36963 }
36964 arg1 = reinterpret_cast< wxWindow * >(argp1);
36965 ecode2 = SWIG_AsVal_int(obj1, &val2);
36966 if (!SWIG_IsOK(ecode2)) {
36967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36968 }
36969 arg2 = static_cast< int >(val2);
36970 {
36971 PyThreadState* __tstate = wxPyBeginAllowThreads();
36972 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36973 wxPyEndAllowThreads(__tstate);
36974 if (PyErr_Occurred()) SWIG_fail;
36975 }
36976 {
36977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36978 }
36979 return resultobj;
36980 fail:
36981 return NULL;
36982 }
36983
36984
36985 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36986 PyObject *resultobj = 0;
36987 wxWindow *arg1 = (wxWindow *) 0 ;
36988 int arg2 ;
36989 int arg3 ;
36990 int arg4 ;
36991 int arg5 ;
36992 bool arg6 = (bool) true ;
36993 void *argp1 = 0 ;
36994 int res1 = 0 ;
36995 int val2 ;
36996 int ecode2 = 0 ;
36997 int val3 ;
36998 int ecode3 = 0 ;
36999 int val4 ;
37000 int ecode4 = 0 ;
37001 int val5 ;
37002 int ecode5 = 0 ;
37003 bool val6 ;
37004 int ecode6 = 0 ;
37005 PyObject * obj0 = 0 ;
37006 PyObject * obj1 = 0 ;
37007 PyObject * obj2 = 0 ;
37008 PyObject * obj3 = 0 ;
37009 PyObject * obj4 = 0 ;
37010 PyObject * obj5 = 0 ;
37011 char * kwnames[] = {
37012 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37013 };
37014
37015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37017 if (!SWIG_IsOK(res1)) {
37018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37019 }
37020 arg1 = reinterpret_cast< wxWindow * >(argp1);
37021 ecode2 = SWIG_AsVal_int(obj1, &val2);
37022 if (!SWIG_IsOK(ecode2)) {
37023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37024 }
37025 arg2 = static_cast< int >(val2);
37026 ecode3 = SWIG_AsVal_int(obj2, &val3);
37027 if (!SWIG_IsOK(ecode3)) {
37028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37029 }
37030 arg3 = static_cast< int >(val3);
37031 ecode4 = SWIG_AsVal_int(obj3, &val4);
37032 if (!SWIG_IsOK(ecode4)) {
37033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37034 }
37035 arg4 = static_cast< int >(val4);
37036 ecode5 = SWIG_AsVal_int(obj4, &val5);
37037 if (!SWIG_IsOK(ecode5)) {
37038 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37039 }
37040 arg5 = static_cast< int >(val5);
37041 if (obj5) {
37042 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37043 if (!SWIG_IsOK(ecode6)) {
37044 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37045 }
37046 arg6 = static_cast< bool >(val6);
37047 }
37048 {
37049 PyThreadState* __tstate = wxPyBeginAllowThreads();
37050 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37051 wxPyEndAllowThreads(__tstate);
37052 if (PyErr_Occurred()) SWIG_fail;
37053 }
37054 resultobj = SWIG_Py_Void();
37055 return resultobj;
37056 fail:
37057 return NULL;
37058 }
37059
37060
37061 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37062 PyObject *resultobj = 0;
37063 wxWindow *arg1 = (wxWindow *) 0 ;
37064 int arg2 ;
37065 int arg3 ;
37066 bool arg4 = (bool) true ;
37067 void *argp1 = 0 ;
37068 int res1 = 0 ;
37069 int val2 ;
37070 int ecode2 = 0 ;
37071 int val3 ;
37072 int ecode3 = 0 ;
37073 bool val4 ;
37074 int ecode4 = 0 ;
37075 PyObject * obj0 = 0 ;
37076 PyObject * obj1 = 0 ;
37077 PyObject * obj2 = 0 ;
37078 PyObject * obj3 = 0 ;
37079 char * kwnames[] = {
37080 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37081 };
37082
37083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37087 }
37088 arg1 = reinterpret_cast< wxWindow * >(argp1);
37089 ecode2 = SWIG_AsVal_int(obj1, &val2);
37090 if (!SWIG_IsOK(ecode2)) {
37091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37092 }
37093 arg2 = static_cast< int >(val2);
37094 ecode3 = SWIG_AsVal_int(obj2, &val3);
37095 if (!SWIG_IsOK(ecode3)) {
37096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37097 }
37098 arg3 = static_cast< int >(val3);
37099 if (obj3) {
37100 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37101 if (!SWIG_IsOK(ecode4)) {
37102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37103 }
37104 arg4 = static_cast< bool >(val4);
37105 }
37106 {
37107 PyThreadState* __tstate = wxPyBeginAllowThreads();
37108 (arg1)->SetScrollPos(arg2,arg3,arg4);
37109 wxPyEndAllowThreads(__tstate);
37110 if (PyErr_Occurred()) SWIG_fail;
37111 }
37112 resultobj = SWIG_Py_Void();
37113 return resultobj;
37114 fail:
37115 return NULL;
37116 }
37117
37118
37119 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37120 PyObject *resultobj = 0;
37121 wxWindow *arg1 = (wxWindow *) 0 ;
37122 int arg2 ;
37123 int result;
37124 void *argp1 = 0 ;
37125 int res1 = 0 ;
37126 int val2 ;
37127 int ecode2 = 0 ;
37128 PyObject * obj0 = 0 ;
37129 PyObject * obj1 = 0 ;
37130 char * kwnames[] = {
37131 (char *) "self",(char *) "orientation", NULL
37132 };
37133
37134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37136 if (!SWIG_IsOK(res1)) {
37137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37138 }
37139 arg1 = reinterpret_cast< wxWindow * >(argp1);
37140 ecode2 = SWIG_AsVal_int(obj1, &val2);
37141 if (!SWIG_IsOK(ecode2)) {
37142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37143 }
37144 arg2 = static_cast< int >(val2);
37145 {
37146 PyThreadState* __tstate = wxPyBeginAllowThreads();
37147 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37148 wxPyEndAllowThreads(__tstate);
37149 if (PyErr_Occurred()) SWIG_fail;
37150 }
37151 resultobj = SWIG_From_int(static_cast< int >(result));
37152 return resultobj;
37153 fail:
37154 return NULL;
37155 }
37156
37157
37158 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37159 PyObject *resultobj = 0;
37160 wxWindow *arg1 = (wxWindow *) 0 ;
37161 int arg2 ;
37162 int result;
37163 void *argp1 = 0 ;
37164 int res1 = 0 ;
37165 int val2 ;
37166 int ecode2 = 0 ;
37167 PyObject * obj0 = 0 ;
37168 PyObject * obj1 = 0 ;
37169 char * kwnames[] = {
37170 (char *) "self",(char *) "orientation", NULL
37171 };
37172
37173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37175 if (!SWIG_IsOK(res1)) {
37176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37177 }
37178 arg1 = reinterpret_cast< wxWindow * >(argp1);
37179 ecode2 = SWIG_AsVal_int(obj1, &val2);
37180 if (!SWIG_IsOK(ecode2)) {
37181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37182 }
37183 arg2 = static_cast< int >(val2);
37184 {
37185 PyThreadState* __tstate = wxPyBeginAllowThreads();
37186 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37187 wxPyEndAllowThreads(__tstate);
37188 if (PyErr_Occurred()) SWIG_fail;
37189 }
37190 resultobj = SWIG_From_int(static_cast< int >(result));
37191 return resultobj;
37192 fail:
37193 return NULL;
37194 }
37195
37196
37197 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37198 PyObject *resultobj = 0;
37199 wxWindow *arg1 = (wxWindow *) 0 ;
37200 int arg2 ;
37201 int result;
37202 void *argp1 = 0 ;
37203 int res1 = 0 ;
37204 int val2 ;
37205 int ecode2 = 0 ;
37206 PyObject * obj0 = 0 ;
37207 PyObject * obj1 = 0 ;
37208 char * kwnames[] = {
37209 (char *) "self",(char *) "orientation", NULL
37210 };
37211
37212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37214 if (!SWIG_IsOK(res1)) {
37215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 ecode2 = SWIG_AsVal_int(obj1, &val2);
37219 if (!SWIG_IsOK(ecode2)) {
37220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37221 }
37222 arg2 = static_cast< int >(val2);
37223 {
37224 PyThreadState* __tstate = wxPyBeginAllowThreads();
37225 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37226 wxPyEndAllowThreads(__tstate);
37227 if (PyErr_Occurred()) SWIG_fail;
37228 }
37229 resultobj = SWIG_From_int(static_cast< int >(result));
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37237 PyObject *resultobj = 0;
37238 wxWindow *arg1 = (wxWindow *) 0 ;
37239 int arg2 ;
37240 int arg3 ;
37241 wxRect *arg4 = (wxRect *) NULL ;
37242 void *argp1 = 0 ;
37243 int res1 = 0 ;
37244 int val2 ;
37245 int ecode2 = 0 ;
37246 int val3 ;
37247 int ecode3 = 0 ;
37248 void *argp4 = 0 ;
37249 int res4 = 0 ;
37250 PyObject * obj0 = 0 ;
37251 PyObject * obj1 = 0 ;
37252 PyObject * obj2 = 0 ;
37253 PyObject * obj3 = 0 ;
37254 char * kwnames[] = {
37255 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37256 };
37257
37258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37260 if (!SWIG_IsOK(res1)) {
37261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37262 }
37263 arg1 = reinterpret_cast< wxWindow * >(argp1);
37264 ecode2 = SWIG_AsVal_int(obj1, &val2);
37265 if (!SWIG_IsOK(ecode2)) {
37266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37267 }
37268 arg2 = static_cast< int >(val2);
37269 ecode3 = SWIG_AsVal_int(obj2, &val3);
37270 if (!SWIG_IsOK(ecode3)) {
37271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37272 }
37273 arg3 = static_cast< int >(val3);
37274 if (obj3) {
37275 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37276 if (!SWIG_IsOK(res4)) {
37277 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37278 }
37279 arg4 = reinterpret_cast< wxRect * >(argp4);
37280 }
37281 {
37282 PyThreadState* __tstate = wxPyBeginAllowThreads();
37283 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37284 wxPyEndAllowThreads(__tstate);
37285 if (PyErr_Occurred()) SWIG_fail;
37286 }
37287 resultobj = SWIG_Py_Void();
37288 return resultobj;
37289 fail:
37290 return NULL;
37291 }
37292
37293
37294 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37295 PyObject *resultobj = 0;
37296 wxWindow *arg1 = (wxWindow *) 0 ;
37297 int arg2 ;
37298 bool result;
37299 void *argp1 = 0 ;
37300 int res1 = 0 ;
37301 int val2 ;
37302 int ecode2 = 0 ;
37303 PyObject * obj0 = 0 ;
37304 PyObject * obj1 = 0 ;
37305 char * kwnames[] = {
37306 (char *) "self",(char *) "lines", NULL
37307 };
37308
37309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37311 if (!SWIG_IsOK(res1)) {
37312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37313 }
37314 arg1 = reinterpret_cast< wxWindow * >(argp1);
37315 ecode2 = SWIG_AsVal_int(obj1, &val2);
37316 if (!SWIG_IsOK(ecode2)) {
37317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37318 }
37319 arg2 = static_cast< int >(val2);
37320 {
37321 PyThreadState* __tstate = wxPyBeginAllowThreads();
37322 result = (bool)(arg1)->ScrollLines(arg2);
37323 wxPyEndAllowThreads(__tstate);
37324 if (PyErr_Occurred()) SWIG_fail;
37325 }
37326 {
37327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37328 }
37329 return resultobj;
37330 fail:
37331 return NULL;
37332 }
37333
37334
37335 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37336 PyObject *resultobj = 0;
37337 wxWindow *arg1 = (wxWindow *) 0 ;
37338 int arg2 ;
37339 bool result;
37340 void *argp1 = 0 ;
37341 int res1 = 0 ;
37342 int val2 ;
37343 int ecode2 = 0 ;
37344 PyObject * obj0 = 0 ;
37345 PyObject * obj1 = 0 ;
37346 char * kwnames[] = {
37347 (char *) "self",(char *) "pages", NULL
37348 };
37349
37350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37352 if (!SWIG_IsOK(res1)) {
37353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37354 }
37355 arg1 = reinterpret_cast< wxWindow * >(argp1);
37356 ecode2 = SWIG_AsVal_int(obj1, &val2);
37357 if (!SWIG_IsOK(ecode2)) {
37358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37359 }
37360 arg2 = static_cast< int >(val2);
37361 {
37362 PyThreadState* __tstate = wxPyBeginAllowThreads();
37363 result = (bool)(arg1)->ScrollPages(arg2);
37364 wxPyEndAllowThreads(__tstate);
37365 if (PyErr_Occurred()) SWIG_fail;
37366 }
37367 {
37368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37369 }
37370 return resultobj;
37371 fail:
37372 return NULL;
37373 }
37374
37375
37376 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37377 PyObject *resultobj = 0;
37378 wxWindow *arg1 = (wxWindow *) 0 ;
37379 bool result;
37380 void *argp1 = 0 ;
37381 int res1 = 0 ;
37382 PyObject *swig_obj[1] ;
37383
37384 if (!args) SWIG_fail;
37385 swig_obj[0] = args;
37386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37387 if (!SWIG_IsOK(res1)) {
37388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37389 }
37390 arg1 = reinterpret_cast< wxWindow * >(argp1);
37391 {
37392 PyThreadState* __tstate = wxPyBeginAllowThreads();
37393 result = (bool)(arg1)->LineUp();
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 {
37398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37399 }
37400 return resultobj;
37401 fail:
37402 return NULL;
37403 }
37404
37405
37406 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37407 PyObject *resultobj = 0;
37408 wxWindow *arg1 = (wxWindow *) 0 ;
37409 bool result;
37410 void *argp1 = 0 ;
37411 int res1 = 0 ;
37412 PyObject *swig_obj[1] ;
37413
37414 if (!args) SWIG_fail;
37415 swig_obj[0] = args;
37416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37417 if (!SWIG_IsOK(res1)) {
37418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37419 }
37420 arg1 = reinterpret_cast< wxWindow * >(argp1);
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 result = (bool)(arg1)->LineDown();
37424 wxPyEndAllowThreads(__tstate);
37425 if (PyErr_Occurred()) SWIG_fail;
37426 }
37427 {
37428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37429 }
37430 return resultobj;
37431 fail:
37432 return NULL;
37433 }
37434
37435
37436 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37437 PyObject *resultobj = 0;
37438 wxWindow *arg1 = (wxWindow *) 0 ;
37439 bool result;
37440 void *argp1 = 0 ;
37441 int res1 = 0 ;
37442 PyObject *swig_obj[1] ;
37443
37444 if (!args) SWIG_fail;
37445 swig_obj[0] = args;
37446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37447 if (!SWIG_IsOK(res1)) {
37448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37449 }
37450 arg1 = reinterpret_cast< wxWindow * >(argp1);
37451 {
37452 PyThreadState* __tstate = wxPyBeginAllowThreads();
37453 result = (bool)(arg1)->PageUp();
37454 wxPyEndAllowThreads(__tstate);
37455 if (PyErr_Occurred()) SWIG_fail;
37456 }
37457 {
37458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37459 }
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37467 PyObject *resultobj = 0;
37468 wxWindow *arg1 = (wxWindow *) 0 ;
37469 bool result;
37470 void *argp1 = 0 ;
37471 int res1 = 0 ;
37472 PyObject *swig_obj[1] ;
37473
37474 if (!args) SWIG_fail;
37475 swig_obj[0] = args;
37476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37477 if (!SWIG_IsOK(res1)) {
37478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37479 }
37480 arg1 = reinterpret_cast< wxWindow * >(argp1);
37481 {
37482 PyThreadState* __tstate = wxPyBeginAllowThreads();
37483 result = (bool)(arg1)->PageDown();
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 {
37488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37489 }
37490 return resultobj;
37491 fail:
37492 return NULL;
37493 }
37494
37495
37496 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37497 PyObject *resultobj = 0;
37498 wxWindow *arg1 = (wxWindow *) 0 ;
37499 wxString *arg2 = 0 ;
37500 void *argp1 = 0 ;
37501 int res1 = 0 ;
37502 bool temp2 = false ;
37503 PyObject * obj0 = 0 ;
37504 PyObject * obj1 = 0 ;
37505 char * kwnames[] = {
37506 (char *) "self",(char *) "text", NULL
37507 };
37508
37509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37511 if (!SWIG_IsOK(res1)) {
37512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37513 }
37514 arg1 = reinterpret_cast< wxWindow * >(argp1);
37515 {
37516 arg2 = wxString_in_helper(obj1);
37517 if (arg2 == NULL) SWIG_fail;
37518 temp2 = true;
37519 }
37520 {
37521 PyThreadState* __tstate = wxPyBeginAllowThreads();
37522 (arg1)->SetHelpText((wxString const &)*arg2);
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 resultobj = SWIG_Py_Void();
37527 {
37528 if (temp2)
37529 delete arg2;
37530 }
37531 return resultobj;
37532 fail:
37533 {
37534 if (temp2)
37535 delete arg2;
37536 }
37537 return NULL;
37538 }
37539
37540
37541 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37542 PyObject *resultobj = 0;
37543 wxWindow *arg1 = (wxWindow *) 0 ;
37544 wxString *arg2 = 0 ;
37545 void *argp1 = 0 ;
37546 int res1 = 0 ;
37547 bool temp2 = false ;
37548 PyObject * obj0 = 0 ;
37549 PyObject * obj1 = 0 ;
37550 char * kwnames[] = {
37551 (char *) "self",(char *) "text", NULL
37552 };
37553
37554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37556 if (!SWIG_IsOK(res1)) {
37557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37558 }
37559 arg1 = reinterpret_cast< wxWindow * >(argp1);
37560 {
37561 arg2 = wxString_in_helper(obj1);
37562 if (arg2 == NULL) SWIG_fail;
37563 temp2 = true;
37564 }
37565 {
37566 PyThreadState* __tstate = wxPyBeginAllowThreads();
37567 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37568 wxPyEndAllowThreads(__tstate);
37569 if (PyErr_Occurred()) SWIG_fail;
37570 }
37571 resultobj = SWIG_Py_Void();
37572 {
37573 if (temp2)
37574 delete arg2;
37575 }
37576 return resultobj;
37577 fail:
37578 {
37579 if (temp2)
37580 delete arg2;
37581 }
37582 return NULL;
37583 }
37584
37585
37586 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37587 PyObject *resultobj = 0;
37588 wxWindow *arg1 = (wxWindow *) 0 ;
37589 wxPoint *arg2 = 0 ;
37590 wxHelpEvent::Origin arg3 ;
37591 wxString result;
37592 void *argp1 = 0 ;
37593 int res1 = 0 ;
37594 wxPoint temp2 ;
37595 void *argp3 ;
37596 int res3 = 0 ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 PyObject * obj2 = 0 ;
37600 char * kwnames[] = {
37601 (char *) "self",(char *) "pt",(char *) "origin", NULL
37602 };
37603
37604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37606 if (!SWIG_IsOK(res1)) {
37607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37608 }
37609 arg1 = reinterpret_cast< wxWindow * >(argp1);
37610 {
37611 arg2 = &temp2;
37612 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37613 }
37614 {
37615 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37616 if (!SWIG_IsOK(res3)) {
37617 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37618 }
37619 if (!argp3) {
37620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37621 } else {
37622 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37623 arg3 = *temp;
37624 if (SWIG_IsNewObj(res3)) delete temp;
37625 }
37626 }
37627 {
37628 PyThreadState* __tstate = wxPyBeginAllowThreads();
37629 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37630 wxPyEndAllowThreads(__tstate);
37631 if (PyErr_Occurred()) SWIG_fail;
37632 }
37633 {
37634 #if wxUSE_UNICODE
37635 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37636 #else
37637 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37638 #endif
37639 }
37640 return resultobj;
37641 fail:
37642 return NULL;
37643 }
37644
37645
37646 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37647 PyObject *resultobj = 0;
37648 wxWindow *arg1 = (wxWindow *) 0 ;
37649 wxString result;
37650 void *argp1 = 0 ;
37651 int res1 = 0 ;
37652 PyObject *swig_obj[1] ;
37653
37654 if (!args) SWIG_fail;
37655 swig_obj[0] = args;
37656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37657 if (!SWIG_IsOK(res1)) {
37658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37659 }
37660 arg1 = reinterpret_cast< wxWindow * >(argp1);
37661 {
37662 PyThreadState* __tstate = wxPyBeginAllowThreads();
37663 result = ((wxWindow const *)arg1)->GetHelpText();
37664 wxPyEndAllowThreads(__tstate);
37665 if (PyErr_Occurred()) SWIG_fail;
37666 }
37667 {
37668 #if wxUSE_UNICODE
37669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37670 #else
37671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37672 #endif
37673 }
37674 return resultobj;
37675 fail:
37676 return NULL;
37677 }
37678
37679
37680 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37681 PyObject *resultobj = 0;
37682 wxWindow *arg1 = (wxWindow *) 0 ;
37683 wxString *arg2 = 0 ;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 bool temp2 = false ;
37687 PyObject * obj0 = 0 ;
37688 PyObject * obj1 = 0 ;
37689 char * kwnames[] = {
37690 (char *) "self",(char *) "tip", NULL
37691 };
37692
37693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37695 if (!SWIG_IsOK(res1)) {
37696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37697 }
37698 arg1 = reinterpret_cast< wxWindow * >(argp1);
37699 {
37700 arg2 = wxString_in_helper(obj1);
37701 if (arg2 == NULL) SWIG_fail;
37702 temp2 = true;
37703 }
37704 {
37705 PyThreadState* __tstate = wxPyBeginAllowThreads();
37706 (arg1)->SetToolTip((wxString const &)*arg2);
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 resultobj = SWIG_Py_Void();
37711 {
37712 if (temp2)
37713 delete arg2;
37714 }
37715 return resultobj;
37716 fail:
37717 {
37718 if (temp2)
37719 delete arg2;
37720 }
37721 return NULL;
37722 }
37723
37724
37725 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37726 PyObject *resultobj = 0;
37727 wxWindow *arg1 = (wxWindow *) 0 ;
37728 wxToolTip *arg2 = (wxToolTip *) 0 ;
37729 void *argp1 = 0 ;
37730 int res1 = 0 ;
37731 int res2 = 0 ;
37732 PyObject * obj0 = 0 ;
37733 PyObject * obj1 = 0 ;
37734 char * kwnames[] = {
37735 (char *) "self",(char *) "tip", NULL
37736 };
37737
37738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37740 if (!SWIG_IsOK(res1)) {
37741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37742 }
37743 arg1 = reinterpret_cast< wxWindow * >(argp1);
37744 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37745 if (!SWIG_IsOK(res2)) {
37746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37747 }
37748 {
37749 PyThreadState* __tstate = wxPyBeginAllowThreads();
37750 (arg1)->SetToolTip(arg2);
37751 wxPyEndAllowThreads(__tstate);
37752 if (PyErr_Occurred()) SWIG_fail;
37753 }
37754 resultobj = SWIG_Py_Void();
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37762 PyObject *resultobj = 0;
37763 wxWindow *arg1 = (wxWindow *) 0 ;
37764 wxToolTip *result = 0 ;
37765 void *argp1 = 0 ;
37766 int res1 = 0 ;
37767 PyObject *swig_obj[1] ;
37768
37769 if (!args) SWIG_fail;
37770 swig_obj[0] = args;
37771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37772 if (!SWIG_IsOK(res1)) {
37773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37774 }
37775 arg1 = reinterpret_cast< wxWindow * >(argp1);
37776 {
37777 PyThreadState* __tstate = wxPyBeginAllowThreads();
37778 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 {
37783 resultobj = wxPyMake_wxObject(result, (bool)0);
37784 }
37785 return resultobj;
37786 fail:
37787 return NULL;
37788 }
37789
37790
37791 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37792 PyObject *resultobj = 0;
37793 wxWindow *arg1 = (wxWindow *) 0 ;
37794 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 int res2 = 0 ;
37798 PyObject * obj0 = 0 ;
37799 PyObject * obj1 = 0 ;
37800 char * kwnames[] = {
37801 (char *) "self",(char *) "dropTarget", NULL
37802 };
37803
37804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37806 if (!SWIG_IsOK(res1)) {
37807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37808 }
37809 arg1 = reinterpret_cast< wxWindow * >(argp1);
37810 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37811 if (!SWIG_IsOK(res2)) {
37812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37813 }
37814 {
37815 PyThreadState* __tstate = wxPyBeginAllowThreads();
37816 (arg1)->SetDropTarget(arg2);
37817 wxPyEndAllowThreads(__tstate);
37818 if (PyErr_Occurred()) SWIG_fail;
37819 }
37820 resultobj = SWIG_Py_Void();
37821 return resultobj;
37822 fail:
37823 return NULL;
37824 }
37825
37826
37827 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37828 PyObject *resultobj = 0;
37829 wxWindow *arg1 = (wxWindow *) 0 ;
37830 wxPyDropTarget *result = 0 ;
37831 void *argp1 = 0 ;
37832 int res1 = 0 ;
37833 PyObject *swig_obj[1] ;
37834
37835 if (!args) SWIG_fail;
37836 swig_obj[0] = args;
37837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37838 if (!SWIG_IsOK(res1)) {
37839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37840 }
37841 arg1 = reinterpret_cast< wxWindow * >(argp1);
37842 {
37843 PyThreadState* __tstate = wxPyBeginAllowThreads();
37844 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37845 wxPyEndAllowThreads(__tstate);
37846 if (PyErr_Occurred()) SWIG_fail;
37847 }
37848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37849 return resultobj;
37850 fail:
37851 return NULL;
37852 }
37853
37854
37855 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37856 PyObject *resultobj = 0;
37857 wxWindow *arg1 = (wxWindow *) 0 ;
37858 bool arg2 ;
37859 void *argp1 = 0 ;
37860 int res1 = 0 ;
37861 bool val2 ;
37862 int ecode2 = 0 ;
37863 PyObject * obj0 = 0 ;
37864 PyObject * obj1 = 0 ;
37865 char * kwnames[] = {
37866 (char *) "self",(char *) "accept", NULL
37867 };
37868
37869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37871 if (!SWIG_IsOK(res1)) {
37872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37873 }
37874 arg1 = reinterpret_cast< wxWindow * >(argp1);
37875 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37876 if (!SWIG_IsOK(ecode2)) {
37877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37878 }
37879 arg2 = static_cast< bool >(val2);
37880 {
37881 PyThreadState* __tstate = wxPyBeginAllowThreads();
37882 (arg1)->DragAcceptFiles(arg2);
37883 wxPyEndAllowThreads(__tstate);
37884 if (PyErr_Occurred()) SWIG_fail;
37885 }
37886 resultobj = SWIG_Py_Void();
37887 return resultobj;
37888 fail:
37889 return NULL;
37890 }
37891
37892
37893 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37894 PyObject *resultobj = 0;
37895 wxWindow *arg1 = (wxWindow *) 0 ;
37896 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37897 void *argp1 = 0 ;
37898 int res1 = 0 ;
37899 int res2 = 0 ;
37900 PyObject * obj0 = 0 ;
37901 PyObject * obj1 = 0 ;
37902 char * kwnames[] = {
37903 (char *) "self",(char *) "constraints", NULL
37904 };
37905
37906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37908 if (!SWIG_IsOK(res1)) {
37909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37910 }
37911 arg1 = reinterpret_cast< wxWindow * >(argp1);
37912 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37913 if (!SWIG_IsOK(res2)) {
37914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37915 }
37916 {
37917 PyThreadState* __tstate = wxPyBeginAllowThreads();
37918 (arg1)->SetConstraints(arg2);
37919 wxPyEndAllowThreads(__tstate);
37920 if (PyErr_Occurred()) SWIG_fail;
37921 }
37922 resultobj = SWIG_Py_Void();
37923 return resultobj;
37924 fail:
37925 return NULL;
37926 }
37927
37928
37929 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37930 PyObject *resultobj = 0;
37931 wxWindow *arg1 = (wxWindow *) 0 ;
37932 wxLayoutConstraints *result = 0 ;
37933 void *argp1 = 0 ;
37934 int res1 = 0 ;
37935 PyObject *swig_obj[1] ;
37936
37937 if (!args) SWIG_fail;
37938 swig_obj[0] = args;
37939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37940 if (!SWIG_IsOK(res1)) {
37941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37942 }
37943 arg1 = reinterpret_cast< wxWindow * >(argp1);
37944 {
37945 PyThreadState* __tstate = wxPyBeginAllowThreads();
37946 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37947 wxPyEndAllowThreads(__tstate);
37948 if (PyErr_Occurred()) SWIG_fail;
37949 }
37950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37951 return resultobj;
37952 fail:
37953 return NULL;
37954 }
37955
37956
37957 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37958 PyObject *resultobj = 0;
37959 wxWindow *arg1 = (wxWindow *) 0 ;
37960 bool arg2 ;
37961 void *argp1 = 0 ;
37962 int res1 = 0 ;
37963 bool val2 ;
37964 int ecode2 = 0 ;
37965 PyObject * obj0 = 0 ;
37966 PyObject * obj1 = 0 ;
37967 char * kwnames[] = {
37968 (char *) "self",(char *) "autoLayout", NULL
37969 };
37970
37971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37973 if (!SWIG_IsOK(res1)) {
37974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37975 }
37976 arg1 = reinterpret_cast< wxWindow * >(argp1);
37977 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37978 if (!SWIG_IsOK(ecode2)) {
37979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37980 }
37981 arg2 = static_cast< bool >(val2);
37982 {
37983 PyThreadState* __tstate = wxPyBeginAllowThreads();
37984 (arg1)->SetAutoLayout(arg2);
37985 wxPyEndAllowThreads(__tstate);
37986 if (PyErr_Occurred()) SWIG_fail;
37987 }
37988 resultobj = SWIG_Py_Void();
37989 return resultobj;
37990 fail:
37991 return NULL;
37992 }
37993
37994
37995 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37996 PyObject *resultobj = 0;
37997 wxWindow *arg1 = (wxWindow *) 0 ;
37998 bool result;
37999 void *argp1 = 0 ;
38000 int res1 = 0 ;
38001 PyObject *swig_obj[1] ;
38002
38003 if (!args) SWIG_fail;
38004 swig_obj[0] = args;
38005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38006 if (!SWIG_IsOK(res1)) {
38007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38008 }
38009 arg1 = reinterpret_cast< wxWindow * >(argp1);
38010 {
38011 PyThreadState* __tstate = wxPyBeginAllowThreads();
38012 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38013 wxPyEndAllowThreads(__tstate);
38014 if (PyErr_Occurred()) SWIG_fail;
38015 }
38016 {
38017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38018 }
38019 return resultobj;
38020 fail:
38021 return NULL;
38022 }
38023
38024
38025 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38026 PyObject *resultobj = 0;
38027 wxWindow *arg1 = (wxWindow *) 0 ;
38028 bool result;
38029 void *argp1 = 0 ;
38030 int res1 = 0 ;
38031 PyObject *swig_obj[1] ;
38032
38033 if (!args) SWIG_fail;
38034 swig_obj[0] = args;
38035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38036 if (!SWIG_IsOK(res1)) {
38037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38038 }
38039 arg1 = reinterpret_cast< wxWindow * >(argp1);
38040 {
38041 PyThreadState* __tstate = wxPyBeginAllowThreads();
38042 result = (bool)(arg1)->Layout();
38043 wxPyEndAllowThreads(__tstate);
38044 if (PyErr_Occurred()) SWIG_fail;
38045 }
38046 {
38047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38048 }
38049 return resultobj;
38050 fail:
38051 return NULL;
38052 }
38053
38054
38055 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38056 PyObject *resultobj = 0;
38057 wxWindow *arg1 = (wxWindow *) 0 ;
38058 wxSizer *arg2 = (wxSizer *) 0 ;
38059 bool arg3 = (bool) true ;
38060 void *argp1 = 0 ;
38061 int res1 = 0 ;
38062 int res2 = 0 ;
38063 bool val3 ;
38064 int ecode3 = 0 ;
38065 PyObject * obj0 = 0 ;
38066 PyObject * obj1 = 0 ;
38067 PyObject * obj2 = 0 ;
38068 char * kwnames[] = {
38069 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38070 };
38071
38072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38074 if (!SWIG_IsOK(res1)) {
38075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38076 }
38077 arg1 = reinterpret_cast< wxWindow * >(argp1);
38078 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38079 if (!SWIG_IsOK(res2)) {
38080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38081 }
38082 if (obj2) {
38083 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38084 if (!SWIG_IsOK(ecode3)) {
38085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38086 }
38087 arg3 = static_cast< bool >(val3);
38088 }
38089 {
38090 PyThreadState* __tstate = wxPyBeginAllowThreads();
38091 (arg1)->SetSizer(arg2,arg3);
38092 wxPyEndAllowThreads(__tstate);
38093 if (PyErr_Occurred()) SWIG_fail;
38094 }
38095 resultobj = SWIG_Py_Void();
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj = 0;
38104 wxWindow *arg1 = (wxWindow *) 0 ;
38105 wxSizer *arg2 = (wxSizer *) 0 ;
38106 bool arg3 = (bool) true ;
38107 void *argp1 = 0 ;
38108 int res1 = 0 ;
38109 int res2 = 0 ;
38110 bool val3 ;
38111 int ecode3 = 0 ;
38112 PyObject * obj0 = 0 ;
38113 PyObject * obj1 = 0 ;
38114 PyObject * obj2 = 0 ;
38115 char * kwnames[] = {
38116 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38117 };
38118
38119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38121 if (!SWIG_IsOK(res1)) {
38122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38123 }
38124 arg1 = reinterpret_cast< wxWindow * >(argp1);
38125 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38126 if (!SWIG_IsOK(res2)) {
38127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38128 }
38129 if (obj2) {
38130 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38131 if (!SWIG_IsOK(ecode3)) {
38132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38133 }
38134 arg3 = static_cast< bool >(val3);
38135 }
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 (arg1)->SetSizerAndFit(arg2,arg3);
38139 wxPyEndAllowThreads(__tstate);
38140 if (PyErr_Occurred()) SWIG_fail;
38141 }
38142 resultobj = SWIG_Py_Void();
38143 return resultobj;
38144 fail:
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38150 PyObject *resultobj = 0;
38151 wxWindow *arg1 = (wxWindow *) 0 ;
38152 wxSizer *result = 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 PyObject *swig_obj[1] ;
38156
38157 if (!args) SWIG_fail;
38158 swig_obj[0] = args;
38159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38162 }
38163 arg1 = reinterpret_cast< wxWindow * >(argp1);
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 {
38171 resultobj = wxPyMake_wxObject(result, (bool)0);
38172 }
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38180 PyObject *resultobj = 0;
38181 wxWindow *arg1 = (wxWindow *) 0 ;
38182 wxSizer *arg2 = (wxSizer *) 0 ;
38183 void *argp1 = 0 ;
38184 int res1 = 0 ;
38185 void *argp2 = 0 ;
38186 int res2 = 0 ;
38187 PyObject * obj0 = 0 ;
38188 PyObject * obj1 = 0 ;
38189 char * kwnames[] = {
38190 (char *) "self",(char *) "sizer", NULL
38191 };
38192
38193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38195 if (!SWIG_IsOK(res1)) {
38196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38197 }
38198 arg1 = reinterpret_cast< wxWindow * >(argp1);
38199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38200 if (!SWIG_IsOK(res2)) {
38201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38202 }
38203 arg2 = reinterpret_cast< wxSizer * >(argp2);
38204 {
38205 PyThreadState* __tstate = wxPyBeginAllowThreads();
38206 (arg1)->SetContainingSizer(arg2);
38207 wxPyEndAllowThreads(__tstate);
38208 if (PyErr_Occurred()) SWIG_fail;
38209 }
38210 resultobj = SWIG_Py_Void();
38211 return resultobj;
38212 fail:
38213 return NULL;
38214 }
38215
38216
38217 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38218 PyObject *resultobj = 0;
38219 wxWindow *arg1 = (wxWindow *) 0 ;
38220 wxSizer *result = 0 ;
38221 void *argp1 = 0 ;
38222 int res1 = 0 ;
38223 PyObject *swig_obj[1] ;
38224
38225 if (!args) SWIG_fail;
38226 swig_obj[0] = args;
38227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38228 if (!SWIG_IsOK(res1)) {
38229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38230 }
38231 arg1 = reinterpret_cast< wxWindow * >(argp1);
38232 {
38233 PyThreadState* __tstate = wxPyBeginAllowThreads();
38234 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38235 wxPyEndAllowThreads(__tstate);
38236 if (PyErr_Occurred()) SWIG_fail;
38237 }
38238 {
38239 resultobj = wxPyMake_wxObject(result, (bool)0);
38240 }
38241 return resultobj;
38242 fail:
38243 return NULL;
38244 }
38245
38246
38247 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38248 PyObject *resultobj = 0;
38249 wxWindow *arg1 = (wxWindow *) 0 ;
38250 void *argp1 = 0 ;
38251 int res1 = 0 ;
38252 PyObject *swig_obj[1] ;
38253
38254 if (!args) SWIG_fail;
38255 swig_obj[0] = args;
38256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38257 if (!SWIG_IsOK(res1)) {
38258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38259 }
38260 arg1 = reinterpret_cast< wxWindow * >(argp1);
38261 {
38262 PyThreadState* __tstate = wxPyBeginAllowThreads();
38263 (arg1)->InheritAttributes();
38264 wxPyEndAllowThreads(__tstate);
38265 if (PyErr_Occurred()) SWIG_fail;
38266 }
38267 resultobj = SWIG_Py_Void();
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38275 PyObject *resultobj = 0;
38276 wxWindow *arg1 = (wxWindow *) 0 ;
38277 bool result;
38278 void *argp1 = 0 ;
38279 int res1 = 0 ;
38280 PyObject *swig_obj[1] ;
38281
38282 if (!args) SWIG_fail;
38283 swig_obj[0] = args;
38284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38285 if (!SWIG_IsOK(res1)) {
38286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38287 }
38288 arg1 = reinterpret_cast< wxWindow * >(argp1);
38289 {
38290 PyThreadState* __tstate = wxPyBeginAllowThreads();
38291 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38292 wxPyEndAllowThreads(__tstate);
38293 if (PyErr_Occurred()) SWIG_fail;
38294 }
38295 {
38296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38297 }
38298 return resultobj;
38299 fail:
38300 return NULL;
38301 }
38302
38303
38304 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38305 PyObject *resultobj = 0;
38306 wxWindow *arg1 = (wxWindow *) 0 ;
38307 bool result;
38308 void *argp1 = 0 ;
38309 int res1 = 0 ;
38310 PyObject *swig_obj[1] ;
38311
38312 if (!args) SWIG_fail;
38313 swig_obj[0] = args;
38314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38315 if (!SWIG_IsOK(res1)) {
38316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38317 }
38318 arg1 = reinterpret_cast< wxWindow * >(argp1);
38319 {
38320 PyThreadState* __tstate = wxPyBeginAllowThreads();
38321 result = (bool)(arg1)->CanSetTransparent();
38322 wxPyEndAllowThreads(__tstate);
38323 if (PyErr_Occurred()) SWIG_fail;
38324 }
38325 {
38326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38327 }
38328 return resultobj;
38329 fail:
38330 return NULL;
38331 }
38332
38333
38334 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38335 PyObject *resultobj = 0;
38336 wxWindow *arg1 = (wxWindow *) 0 ;
38337 byte arg2 ;
38338 bool result;
38339 void *argp1 = 0 ;
38340 int res1 = 0 ;
38341 unsigned char val2 ;
38342 int ecode2 = 0 ;
38343 PyObject * obj0 = 0 ;
38344 PyObject * obj1 = 0 ;
38345 char * kwnames[] = {
38346 (char *) "self",(char *) "alpha", NULL
38347 };
38348
38349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38351 if (!SWIG_IsOK(res1)) {
38352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38353 }
38354 arg1 = reinterpret_cast< wxWindow * >(argp1);
38355 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38356 if (!SWIG_IsOK(ecode2)) {
38357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38358 }
38359 arg2 = static_cast< byte >(val2);
38360 {
38361 PyThreadState* __tstate = wxPyBeginAllowThreads();
38362 result = (bool)(arg1)->SetTransparent(arg2);
38363 wxPyEndAllowThreads(__tstate);
38364 if (PyErr_Occurred()) SWIG_fail;
38365 }
38366 {
38367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38368 }
38369 return resultobj;
38370 fail:
38371 return NULL;
38372 }
38373
38374
38375 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38376 PyObject *obj;
38377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38378 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38379 return SWIG_Py_Void();
38380 }
38381
38382 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38383 return SWIG_Python_InitShadowInstance(args);
38384 }
38385
38386 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38387 PyObject *resultobj = 0;
38388 long arg1 ;
38389 wxWindow *arg2 = (wxWindow *) NULL ;
38390 wxWindow *result = 0 ;
38391 long val1 ;
38392 int ecode1 = 0 ;
38393 void *argp2 = 0 ;
38394 int res2 = 0 ;
38395 PyObject * obj0 = 0 ;
38396 PyObject * obj1 = 0 ;
38397 char * kwnames[] = {
38398 (char *) "id",(char *) "parent", NULL
38399 };
38400
38401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38402 ecode1 = SWIG_AsVal_long(obj0, &val1);
38403 if (!SWIG_IsOK(ecode1)) {
38404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38405 }
38406 arg1 = static_cast< long >(val1);
38407 if (obj1) {
38408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38409 if (!SWIG_IsOK(res2)) {
38410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38411 }
38412 arg2 = reinterpret_cast< wxWindow * >(argp2);
38413 }
38414 {
38415 if (!wxPyCheckForApp()) SWIG_fail;
38416 PyThreadState* __tstate = wxPyBeginAllowThreads();
38417 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38418 wxPyEndAllowThreads(__tstate);
38419 if (PyErr_Occurred()) SWIG_fail;
38420 }
38421 {
38422 resultobj = wxPyMake_wxObject(result, 0);
38423 }
38424 return resultobj;
38425 fail:
38426 return NULL;
38427 }
38428
38429
38430 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38431 PyObject *resultobj = 0;
38432 wxString *arg1 = 0 ;
38433 wxWindow *arg2 = (wxWindow *) NULL ;
38434 wxWindow *result = 0 ;
38435 bool temp1 = false ;
38436 void *argp2 = 0 ;
38437 int res2 = 0 ;
38438 PyObject * obj0 = 0 ;
38439 PyObject * obj1 = 0 ;
38440 char * kwnames[] = {
38441 (char *) "name",(char *) "parent", NULL
38442 };
38443
38444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38445 {
38446 arg1 = wxString_in_helper(obj0);
38447 if (arg1 == NULL) SWIG_fail;
38448 temp1 = true;
38449 }
38450 if (obj1) {
38451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38452 if (!SWIG_IsOK(res2)) {
38453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38454 }
38455 arg2 = reinterpret_cast< wxWindow * >(argp2);
38456 }
38457 {
38458 if (!wxPyCheckForApp()) SWIG_fail;
38459 PyThreadState* __tstate = wxPyBeginAllowThreads();
38460 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38461 wxPyEndAllowThreads(__tstate);
38462 if (PyErr_Occurred()) SWIG_fail;
38463 }
38464 {
38465 resultobj = wxPyMake_wxObject(result, 0);
38466 }
38467 {
38468 if (temp1)
38469 delete arg1;
38470 }
38471 return resultobj;
38472 fail:
38473 {
38474 if (temp1)
38475 delete arg1;
38476 }
38477 return NULL;
38478 }
38479
38480
38481 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38482 PyObject *resultobj = 0;
38483 wxString *arg1 = 0 ;
38484 wxWindow *arg2 = (wxWindow *) NULL ;
38485 wxWindow *result = 0 ;
38486 bool temp1 = false ;
38487 void *argp2 = 0 ;
38488 int res2 = 0 ;
38489 PyObject * obj0 = 0 ;
38490 PyObject * obj1 = 0 ;
38491 char * kwnames[] = {
38492 (char *) "label",(char *) "parent", NULL
38493 };
38494
38495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38496 {
38497 arg1 = wxString_in_helper(obj0);
38498 if (arg1 == NULL) SWIG_fail;
38499 temp1 = true;
38500 }
38501 if (obj1) {
38502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38503 if (!SWIG_IsOK(res2)) {
38504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38505 }
38506 arg2 = reinterpret_cast< wxWindow * >(argp2);
38507 }
38508 {
38509 if (!wxPyCheckForApp()) SWIG_fail;
38510 PyThreadState* __tstate = wxPyBeginAllowThreads();
38511 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38512 wxPyEndAllowThreads(__tstate);
38513 if (PyErr_Occurred()) SWIG_fail;
38514 }
38515 {
38516 resultobj = wxPyMake_wxObject(result, 0);
38517 }
38518 {
38519 if (temp1)
38520 delete arg1;
38521 }
38522 return resultobj;
38523 fail:
38524 {
38525 if (temp1)
38526 delete arg1;
38527 }
38528 return NULL;
38529 }
38530
38531
38532 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38533 PyObject *resultobj = 0;
38534 wxWindow *arg1 = (wxWindow *) 0 ;
38535 unsigned long arg2 ;
38536 wxWindow *result = 0 ;
38537 void *argp1 = 0 ;
38538 int res1 = 0 ;
38539 unsigned long val2 ;
38540 int ecode2 = 0 ;
38541 PyObject * obj0 = 0 ;
38542 PyObject * obj1 = 0 ;
38543 char * kwnames[] = {
38544 (char *) "parent",(char *) "_hWnd", NULL
38545 };
38546
38547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38549 if (!SWIG_IsOK(res1)) {
38550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38551 }
38552 arg1 = reinterpret_cast< wxWindow * >(argp1);
38553 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38554 if (!SWIG_IsOK(ecode2)) {
38555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38556 }
38557 arg2 = static_cast< unsigned long >(val2);
38558 {
38559 PyThreadState* __tstate = wxPyBeginAllowThreads();
38560 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38561 wxPyEndAllowThreads(__tstate);
38562 if (PyErr_Occurred()) SWIG_fail;
38563 }
38564 {
38565 resultobj = wxPyMake_wxObject(result, 0);
38566 }
38567 return resultobj;
38568 fail:
38569 return NULL;
38570 }
38571
38572
38573 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38574 PyObject *resultobj = 0;
38575 PyObject *result = 0 ;
38576
38577 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38578 {
38579 PyThreadState* __tstate = wxPyBeginAllowThreads();
38580 result = (PyObject *)GetTopLevelWindows();
38581 wxPyEndAllowThreads(__tstate);
38582 if (PyErr_Occurred()) SWIG_fail;
38583 }
38584 resultobj = result;
38585 return resultobj;
38586 fail:
38587 return NULL;
38588 }
38589
38590
38591 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38592 PyObject *resultobj = 0;
38593 wxValidator *result = 0 ;
38594
38595 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38596 {
38597 PyThreadState* __tstate = wxPyBeginAllowThreads();
38598 result = (wxValidator *)new wxValidator();
38599 wxPyEndAllowThreads(__tstate);
38600 if (PyErr_Occurred()) SWIG_fail;
38601 }
38602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38603 return resultobj;
38604 fail:
38605 return NULL;
38606 }
38607
38608
38609 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38610 PyObject *resultobj = 0;
38611 wxValidator *arg1 = (wxValidator *) 0 ;
38612 wxValidator *result = 0 ;
38613 void *argp1 = 0 ;
38614 int res1 = 0 ;
38615 PyObject *swig_obj[1] ;
38616
38617 if (!args) SWIG_fail;
38618 swig_obj[0] = args;
38619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38620 if (!SWIG_IsOK(res1)) {
38621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38622 }
38623 arg1 = reinterpret_cast< wxValidator * >(argp1);
38624 {
38625 PyThreadState* __tstate = wxPyBeginAllowThreads();
38626 result = (wxValidator *)(arg1)->Clone();
38627 wxPyEndAllowThreads(__tstate);
38628 if (PyErr_Occurred()) SWIG_fail;
38629 }
38630 {
38631 resultobj = wxPyMake_wxObject(result, 0);
38632 }
38633 return resultobj;
38634 fail:
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38640 PyObject *resultobj = 0;
38641 wxValidator *arg1 = (wxValidator *) 0 ;
38642 wxWindow *arg2 = (wxWindow *) 0 ;
38643 bool result;
38644 void *argp1 = 0 ;
38645 int res1 = 0 ;
38646 void *argp2 = 0 ;
38647 int res2 = 0 ;
38648 PyObject * obj0 = 0 ;
38649 PyObject * obj1 = 0 ;
38650 char * kwnames[] = {
38651 (char *) "self",(char *) "parent", NULL
38652 };
38653
38654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38656 if (!SWIG_IsOK(res1)) {
38657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38658 }
38659 arg1 = reinterpret_cast< wxValidator * >(argp1);
38660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38661 if (!SWIG_IsOK(res2)) {
38662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38663 }
38664 arg2 = reinterpret_cast< wxWindow * >(argp2);
38665 {
38666 PyThreadState* __tstate = wxPyBeginAllowThreads();
38667 result = (bool)(arg1)->Validate(arg2);
38668 wxPyEndAllowThreads(__tstate);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 }
38671 {
38672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38673 }
38674 return resultobj;
38675 fail:
38676 return NULL;
38677 }
38678
38679
38680 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38681 PyObject *resultobj = 0;
38682 wxValidator *arg1 = (wxValidator *) 0 ;
38683 bool result;
38684 void *argp1 = 0 ;
38685 int res1 = 0 ;
38686 PyObject *swig_obj[1] ;
38687
38688 if (!args) SWIG_fail;
38689 swig_obj[0] = args;
38690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38691 if (!SWIG_IsOK(res1)) {
38692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38693 }
38694 arg1 = reinterpret_cast< wxValidator * >(argp1);
38695 {
38696 PyThreadState* __tstate = wxPyBeginAllowThreads();
38697 result = (bool)(arg1)->TransferToWindow();
38698 wxPyEndAllowThreads(__tstate);
38699 if (PyErr_Occurred()) SWIG_fail;
38700 }
38701 {
38702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38703 }
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38711 PyObject *resultobj = 0;
38712 wxValidator *arg1 = (wxValidator *) 0 ;
38713 bool result;
38714 void *argp1 = 0 ;
38715 int res1 = 0 ;
38716 PyObject *swig_obj[1] ;
38717
38718 if (!args) SWIG_fail;
38719 swig_obj[0] = args;
38720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38721 if (!SWIG_IsOK(res1)) {
38722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38723 }
38724 arg1 = reinterpret_cast< wxValidator * >(argp1);
38725 {
38726 PyThreadState* __tstate = wxPyBeginAllowThreads();
38727 result = (bool)(arg1)->TransferFromWindow();
38728 wxPyEndAllowThreads(__tstate);
38729 if (PyErr_Occurred()) SWIG_fail;
38730 }
38731 {
38732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38733 }
38734 return resultobj;
38735 fail:
38736 return NULL;
38737 }
38738
38739
38740 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38741 PyObject *resultobj = 0;
38742 wxValidator *arg1 = (wxValidator *) 0 ;
38743 wxWindow *result = 0 ;
38744 void *argp1 = 0 ;
38745 int res1 = 0 ;
38746 PyObject *swig_obj[1] ;
38747
38748 if (!args) SWIG_fail;
38749 swig_obj[0] = args;
38750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38751 if (!SWIG_IsOK(res1)) {
38752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38753 }
38754 arg1 = reinterpret_cast< wxValidator * >(argp1);
38755 {
38756 PyThreadState* __tstate = wxPyBeginAllowThreads();
38757 result = (wxWindow *)(arg1)->GetWindow();
38758 wxPyEndAllowThreads(__tstate);
38759 if (PyErr_Occurred()) SWIG_fail;
38760 }
38761 {
38762 resultobj = wxPyMake_wxObject(result, 0);
38763 }
38764 return resultobj;
38765 fail:
38766 return NULL;
38767 }
38768
38769
38770 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38771 PyObject *resultobj = 0;
38772 wxValidator *arg1 = (wxValidator *) 0 ;
38773 wxWindow *arg2 = (wxWindow *) 0 ;
38774 void *argp1 = 0 ;
38775 int res1 = 0 ;
38776 void *argp2 = 0 ;
38777 int res2 = 0 ;
38778 PyObject * obj0 = 0 ;
38779 PyObject * obj1 = 0 ;
38780 char * kwnames[] = {
38781 (char *) "self",(char *) "window", NULL
38782 };
38783
38784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38786 if (!SWIG_IsOK(res1)) {
38787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38788 }
38789 arg1 = reinterpret_cast< wxValidator * >(argp1);
38790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38791 if (!SWIG_IsOK(res2)) {
38792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38793 }
38794 arg2 = reinterpret_cast< wxWindow * >(argp2);
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 (arg1)->SetWindow(arg2);
38798 wxPyEndAllowThreads(__tstate);
38799 if (PyErr_Occurred()) SWIG_fail;
38800 }
38801 resultobj = SWIG_Py_Void();
38802 return resultobj;
38803 fail:
38804 return NULL;
38805 }
38806
38807
38808 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38809 PyObject *resultobj = 0;
38810 bool result;
38811
38812 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38813 {
38814 PyThreadState* __tstate = wxPyBeginAllowThreads();
38815 result = (bool)wxValidator::IsSilent();
38816 wxPyEndAllowThreads(__tstate);
38817 if (PyErr_Occurred()) SWIG_fail;
38818 }
38819 {
38820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38821 }
38822 return resultobj;
38823 fail:
38824 return NULL;
38825 }
38826
38827
38828 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38829 PyObject *resultobj = 0;
38830 int arg1 = (int) true ;
38831 int val1 ;
38832 int ecode1 = 0 ;
38833 PyObject * obj0 = 0 ;
38834 char * kwnames[] = {
38835 (char *) "doIt", NULL
38836 };
38837
38838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38839 if (obj0) {
38840 ecode1 = SWIG_AsVal_int(obj0, &val1);
38841 if (!SWIG_IsOK(ecode1)) {
38842 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38843 }
38844 arg1 = static_cast< int >(val1);
38845 }
38846 {
38847 PyThreadState* __tstate = wxPyBeginAllowThreads();
38848 wxValidator::SetBellOnError(arg1);
38849 wxPyEndAllowThreads(__tstate);
38850 if (PyErr_Occurred()) SWIG_fail;
38851 }
38852 resultobj = SWIG_Py_Void();
38853 return resultobj;
38854 fail:
38855 return NULL;
38856 }
38857
38858
38859 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38860 PyObject *obj;
38861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38862 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38863 return SWIG_Py_Void();
38864 }
38865
38866 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38867 return SWIG_Python_InitShadowInstance(args);
38868 }
38869
38870 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38871 PyObject *resultobj = 0;
38872 wxPyValidator *result = 0 ;
38873
38874 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38875 {
38876 PyThreadState* __tstate = wxPyBeginAllowThreads();
38877 result = (wxPyValidator *)new wxPyValidator();
38878 wxPyEndAllowThreads(__tstate);
38879 if (PyErr_Occurred()) SWIG_fail;
38880 }
38881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38882 return resultobj;
38883 fail:
38884 return NULL;
38885 }
38886
38887
38888 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38889 PyObject *resultobj = 0;
38890 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38891 PyObject *arg2 = (PyObject *) 0 ;
38892 PyObject *arg3 = (PyObject *) 0 ;
38893 int arg4 = (int) true ;
38894 void *argp1 = 0 ;
38895 int res1 = 0 ;
38896 int val4 ;
38897 int ecode4 = 0 ;
38898 PyObject * obj0 = 0 ;
38899 PyObject * obj1 = 0 ;
38900 PyObject * obj2 = 0 ;
38901 PyObject * obj3 = 0 ;
38902 char * kwnames[] = {
38903 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38904 };
38905
38906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38908 if (!SWIG_IsOK(res1)) {
38909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38910 }
38911 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38912 arg2 = obj1;
38913 arg3 = obj2;
38914 if (obj3) {
38915 ecode4 = SWIG_AsVal_int(obj3, &val4);
38916 if (!SWIG_IsOK(ecode4)) {
38917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38918 }
38919 arg4 = static_cast< int >(val4);
38920 }
38921 {
38922 PyThreadState* __tstate = wxPyBeginAllowThreads();
38923 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38924 wxPyEndAllowThreads(__tstate);
38925 if (PyErr_Occurred()) SWIG_fail;
38926 }
38927 resultobj = SWIG_Py_Void();
38928 return resultobj;
38929 fail:
38930 return NULL;
38931 }
38932
38933
38934 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38935 PyObject *obj;
38936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38937 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38938 return SWIG_Py_Void();
38939 }
38940
38941 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38942 return SWIG_Python_InitShadowInstance(args);
38943 }
38944
38945 SWIGINTERN int DefaultValidator_set(PyObject *) {
38946 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38947 return 1;
38948 }
38949
38950
38951 SWIGINTERN PyObject *DefaultValidator_get(void) {
38952 PyObject *pyobj = 0;
38953
38954 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38955 return pyobj;
38956 }
38957
38958
38959 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38960 PyObject *resultobj = 0;
38961 wxString const &arg1_defvalue = wxPyEmptyString ;
38962 wxString *arg1 = (wxString *) &arg1_defvalue ;
38963 long arg2 = (long) 0 ;
38964 wxMenu *result = 0 ;
38965 bool temp1 = false ;
38966 long val2 ;
38967 int ecode2 = 0 ;
38968 PyObject * obj0 = 0 ;
38969 PyObject * obj1 = 0 ;
38970 char * kwnames[] = {
38971 (char *) "title",(char *) "style", NULL
38972 };
38973
38974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38975 if (obj0) {
38976 {
38977 arg1 = wxString_in_helper(obj0);
38978 if (arg1 == NULL) SWIG_fail;
38979 temp1 = true;
38980 }
38981 }
38982 if (obj1) {
38983 ecode2 = SWIG_AsVal_long(obj1, &val2);
38984 if (!SWIG_IsOK(ecode2)) {
38985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38986 }
38987 arg2 = static_cast< long >(val2);
38988 }
38989 {
38990 if (!wxPyCheckForApp()) SWIG_fail;
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38993 wxPyEndAllowThreads(__tstate);
38994 if (PyErr_Occurred()) SWIG_fail;
38995 }
38996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38997 {
38998 if (temp1)
38999 delete arg1;
39000 }
39001 return resultobj;
39002 fail:
39003 {
39004 if (temp1)
39005 delete arg1;
39006 }
39007 return NULL;
39008 }
39009
39010
39011 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39012 PyObject *resultobj = 0;
39013 wxMenu *arg1 = (wxMenu *) 0 ;
39014 int arg2 ;
39015 wxString const &arg3_defvalue = wxPyEmptyString ;
39016 wxString *arg3 = (wxString *) &arg3_defvalue ;
39017 wxString const &arg4_defvalue = wxPyEmptyString ;
39018 wxString *arg4 = (wxString *) &arg4_defvalue ;
39019 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39020 wxMenuItem *result = 0 ;
39021 void *argp1 = 0 ;
39022 int res1 = 0 ;
39023 int val2 ;
39024 int ecode2 = 0 ;
39025 bool temp3 = false ;
39026 bool temp4 = false ;
39027 int val5 ;
39028 int ecode5 = 0 ;
39029 PyObject * obj0 = 0 ;
39030 PyObject * obj1 = 0 ;
39031 PyObject * obj2 = 0 ;
39032 PyObject * obj3 = 0 ;
39033 PyObject * obj4 = 0 ;
39034 char * kwnames[] = {
39035 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39036 };
39037
39038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39040 if (!SWIG_IsOK(res1)) {
39041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39042 }
39043 arg1 = reinterpret_cast< wxMenu * >(argp1);
39044 ecode2 = SWIG_AsVal_int(obj1, &val2);
39045 if (!SWIG_IsOK(ecode2)) {
39046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39047 }
39048 arg2 = static_cast< int >(val2);
39049 if (obj2) {
39050 {
39051 arg3 = wxString_in_helper(obj2);
39052 if (arg3 == NULL) SWIG_fail;
39053 temp3 = true;
39054 }
39055 }
39056 if (obj3) {
39057 {
39058 arg4 = wxString_in_helper(obj3);
39059 if (arg4 == NULL) SWIG_fail;
39060 temp4 = true;
39061 }
39062 }
39063 if (obj4) {
39064 ecode5 = SWIG_AsVal_int(obj4, &val5);
39065 if (!SWIG_IsOK(ecode5)) {
39066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39067 }
39068 arg5 = static_cast< wxItemKind >(val5);
39069 }
39070 {
39071 PyThreadState* __tstate = wxPyBeginAllowThreads();
39072 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 {
39077 resultobj = wxPyMake_wxObject(result, (bool)0);
39078 }
39079 {
39080 if (temp3)
39081 delete arg3;
39082 }
39083 {
39084 if (temp4)
39085 delete arg4;
39086 }
39087 return resultobj;
39088 fail:
39089 {
39090 if (temp3)
39091 delete arg3;
39092 }
39093 {
39094 if (temp4)
39095 delete arg4;
39096 }
39097 return NULL;
39098 }
39099
39100
39101 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39102 PyObject *resultobj = 0;
39103 wxMenu *arg1 = (wxMenu *) 0 ;
39104 wxMenuItem *result = 0 ;
39105 void *argp1 = 0 ;
39106 int res1 = 0 ;
39107 PyObject *swig_obj[1] ;
39108
39109 if (!args) SWIG_fail;
39110 swig_obj[0] = args;
39111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39112 if (!SWIG_IsOK(res1)) {
39113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39114 }
39115 arg1 = reinterpret_cast< wxMenu * >(argp1);
39116 {
39117 PyThreadState* __tstate = wxPyBeginAllowThreads();
39118 result = (wxMenuItem *)(arg1)->AppendSeparator();
39119 wxPyEndAllowThreads(__tstate);
39120 if (PyErr_Occurred()) SWIG_fail;
39121 }
39122 {
39123 resultobj = wxPyMake_wxObject(result, (bool)0);
39124 }
39125 return resultobj;
39126 fail:
39127 return NULL;
39128 }
39129
39130
39131 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39132 PyObject *resultobj = 0;
39133 wxMenu *arg1 = (wxMenu *) 0 ;
39134 int arg2 ;
39135 wxString *arg3 = 0 ;
39136 wxString const &arg4_defvalue = wxPyEmptyString ;
39137 wxString *arg4 = (wxString *) &arg4_defvalue ;
39138 wxMenuItem *result = 0 ;
39139 void *argp1 = 0 ;
39140 int res1 = 0 ;
39141 int val2 ;
39142 int ecode2 = 0 ;
39143 bool temp3 = false ;
39144 bool temp4 = false ;
39145 PyObject * obj0 = 0 ;
39146 PyObject * obj1 = 0 ;
39147 PyObject * obj2 = 0 ;
39148 PyObject * obj3 = 0 ;
39149 char * kwnames[] = {
39150 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39151 };
39152
39153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39155 if (!SWIG_IsOK(res1)) {
39156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39157 }
39158 arg1 = reinterpret_cast< wxMenu * >(argp1);
39159 ecode2 = SWIG_AsVal_int(obj1, &val2);
39160 if (!SWIG_IsOK(ecode2)) {
39161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39162 }
39163 arg2 = static_cast< int >(val2);
39164 {
39165 arg3 = wxString_in_helper(obj2);
39166 if (arg3 == NULL) SWIG_fail;
39167 temp3 = true;
39168 }
39169 if (obj3) {
39170 {
39171 arg4 = wxString_in_helper(obj3);
39172 if (arg4 == NULL) SWIG_fail;
39173 temp4 = true;
39174 }
39175 }
39176 {
39177 PyThreadState* __tstate = wxPyBeginAllowThreads();
39178 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39179 wxPyEndAllowThreads(__tstate);
39180 if (PyErr_Occurred()) SWIG_fail;
39181 }
39182 {
39183 resultobj = wxPyMake_wxObject(result, (bool)0);
39184 }
39185 {
39186 if (temp3)
39187 delete arg3;
39188 }
39189 {
39190 if (temp4)
39191 delete arg4;
39192 }
39193 return resultobj;
39194 fail:
39195 {
39196 if (temp3)
39197 delete arg3;
39198 }
39199 {
39200 if (temp4)
39201 delete arg4;
39202 }
39203 return NULL;
39204 }
39205
39206
39207 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39208 PyObject *resultobj = 0;
39209 wxMenu *arg1 = (wxMenu *) 0 ;
39210 int arg2 ;
39211 wxString *arg3 = 0 ;
39212 wxString const &arg4_defvalue = wxPyEmptyString ;
39213 wxString *arg4 = (wxString *) &arg4_defvalue ;
39214 wxMenuItem *result = 0 ;
39215 void *argp1 = 0 ;
39216 int res1 = 0 ;
39217 int val2 ;
39218 int ecode2 = 0 ;
39219 bool temp3 = false ;
39220 bool temp4 = false ;
39221 PyObject * obj0 = 0 ;
39222 PyObject * obj1 = 0 ;
39223 PyObject * obj2 = 0 ;
39224 PyObject * obj3 = 0 ;
39225 char * kwnames[] = {
39226 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39227 };
39228
39229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39231 if (!SWIG_IsOK(res1)) {
39232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39233 }
39234 arg1 = reinterpret_cast< wxMenu * >(argp1);
39235 ecode2 = SWIG_AsVal_int(obj1, &val2);
39236 if (!SWIG_IsOK(ecode2)) {
39237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39238 }
39239 arg2 = static_cast< int >(val2);
39240 {
39241 arg3 = wxString_in_helper(obj2);
39242 if (arg3 == NULL) SWIG_fail;
39243 temp3 = true;
39244 }
39245 if (obj3) {
39246 {
39247 arg4 = wxString_in_helper(obj3);
39248 if (arg4 == NULL) SWIG_fail;
39249 temp4 = true;
39250 }
39251 }
39252 {
39253 PyThreadState* __tstate = wxPyBeginAllowThreads();
39254 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39255 wxPyEndAllowThreads(__tstate);
39256 if (PyErr_Occurred()) SWIG_fail;
39257 }
39258 {
39259 resultobj = wxPyMake_wxObject(result, (bool)0);
39260 }
39261 {
39262 if (temp3)
39263 delete arg3;
39264 }
39265 {
39266 if (temp4)
39267 delete arg4;
39268 }
39269 return resultobj;
39270 fail:
39271 {
39272 if (temp3)
39273 delete arg3;
39274 }
39275 {
39276 if (temp4)
39277 delete arg4;
39278 }
39279 return NULL;
39280 }
39281
39282
39283 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39284 PyObject *resultobj = 0;
39285 wxMenu *arg1 = (wxMenu *) 0 ;
39286 int arg2 ;
39287 wxString *arg3 = 0 ;
39288 wxMenu *arg4 = (wxMenu *) 0 ;
39289 wxString const &arg5_defvalue = wxPyEmptyString ;
39290 wxString *arg5 = (wxString *) &arg5_defvalue ;
39291 wxMenuItem *result = 0 ;
39292 void *argp1 = 0 ;
39293 int res1 = 0 ;
39294 int val2 ;
39295 int ecode2 = 0 ;
39296 bool temp3 = false ;
39297 void *argp4 = 0 ;
39298 int res4 = 0 ;
39299 bool temp5 = false ;
39300 PyObject * obj0 = 0 ;
39301 PyObject * obj1 = 0 ;
39302 PyObject * obj2 = 0 ;
39303 PyObject * obj3 = 0 ;
39304 PyObject * obj4 = 0 ;
39305 char * kwnames[] = {
39306 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39307 };
39308
39309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39311 if (!SWIG_IsOK(res1)) {
39312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39313 }
39314 arg1 = reinterpret_cast< wxMenu * >(argp1);
39315 ecode2 = SWIG_AsVal_int(obj1, &val2);
39316 if (!SWIG_IsOK(ecode2)) {
39317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39318 }
39319 arg2 = static_cast< int >(val2);
39320 {
39321 arg3 = wxString_in_helper(obj2);
39322 if (arg3 == NULL) SWIG_fail;
39323 temp3 = true;
39324 }
39325 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39326 if (!SWIG_IsOK(res4)) {
39327 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39328 }
39329 arg4 = reinterpret_cast< wxMenu * >(argp4);
39330 if (obj4) {
39331 {
39332 arg5 = wxString_in_helper(obj4);
39333 if (arg5 == NULL) SWIG_fail;
39334 temp5 = true;
39335 }
39336 }
39337 {
39338 PyThreadState* __tstate = wxPyBeginAllowThreads();
39339 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39340 wxPyEndAllowThreads(__tstate);
39341 if (PyErr_Occurred()) SWIG_fail;
39342 }
39343 {
39344 resultobj = wxPyMake_wxObject(result, (bool)0);
39345 }
39346 {
39347 if (temp3)
39348 delete arg3;
39349 }
39350 {
39351 if (temp5)
39352 delete arg5;
39353 }
39354 return resultobj;
39355 fail:
39356 {
39357 if (temp3)
39358 delete arg3;
39359 }
39360 {
39361 if (temp5)
39362 delete arg5;
39363 }
39364 return NULL;
39365 }
39366
39367
39368 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39369 PyObject *resultobj = 0;
39370 wxMenu *arg1 = (wxMenu *) 0 ;
39371 wxMenu *arg2 = (wxMenu *) 0 ;
39372 wxString *arg3 = 0 ;
39373 wxString const &arg4_defvalue = wxPyEmptyString ;
39374 wxString *arg4 = (wxString *) &arg4_defvalue ;
39375 wxMenuItem *result = 0 ;
39376 void *argp1 = 0 ;
39377 int res1 = 0 ;
39378 void *argp2 = 0 ;
39379 int res2 = 0 ;
39380 bool temp3 = false ;
39381 bool temp4 = false ;
39382 PyObject * obj0 = 0 ;
39383 PyObject * obj1 = 0 ;
39384 PyObject * obj2 = 0 ;
39385 PyObject * obj3 = 0 ;
39386 char * kwnames[] = {
39387 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39388 };
39389
39390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39392 if (!SWIG_IsOK(res1)) {
39393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39394 }
39395 arg1 = reinterpret_cast< wxMenu * >(argp1);
39396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39397 if (!SWIG_IsOK(res2)) {
39398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39399 }
39400 arg2 = reinterpret_cast< wxMenu * >(argp2);
39401 {
39402 arg3 = wxString_in_helper(obj2);
39403 if (arg3 == NULL) SWIG_fail;
39404 temp3 = true;
39405 }
39406 if (obj3) {
39407 {
39408 arg4 = wxString_in_helper(obj3);
39409 if (arg4 == NULL) SWIG_fail;
39410 temp4 = true;
39411 }
39412 }
39413 {
39414 PyThreadState* __tstate = wxPyBeginAllowThreads();
39415 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39416 wxPyEndAllowThreads(__tstate);
39417 if (PyErr_Occurred()) SWIG_fail;
39418 }
39419 {
39420 resultobj = wxPyMake_wxObject(result, (bool)0);
39421 }
39422 {
39423 if (temp3)
39424 delete arg3;
39425 }
39426 {
39427 if (temp4)
39428 delete arg4;
39429 }
39430 return resultobj;
39431 fail:
39432 {
39433 if (temp3)
39434 delete arg3;
39435 }
39436 {
39437 if (temp4)
39438 delete arg4;
39439 }
39440 return NULL;
39441 }
39442
39443
39444 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39445 PyObject *resultobj = 0;
39446 wxMenu *arg1 = (wxMenu *) 0 ;
39447 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39448 wxMenuItem *result = 0 ;
39449 void *argp1 = 0 ;
39450 int res1 = 0 ;
39451 int res2 = 0 ;
39452 PyObject * obj0 = 0 ;
39453 PyObject * obj1 = 0 ;
39454 char * kwnames[] = {
39455 (char *) "self",(char *) "item", NULL
39456 };
39457
39458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39460 if (!SWIG_IsOK(res1)) {
39461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39462 }
39463 arg1 = reinterpret_cast< wxMenu * >(argp1);
39464 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39465 if (!SWIG_IsOK(res2)) {
39466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39467 }
39468 {
39469 PyThreadState* __tstate = wxPyBeginAllowThreads();
39470 result = (wxMenuItem *)(arg1)->Append(arg2);
39471 wxPyEndAllowThreads(__tstate);
39472 if (PyErr_Occurred()) SWIG_fail;
39473 }
39474 {
39475 resultobj = wxPyMake_wxObject(result, (bool)0);
39476 }
39477 return resultobj;
39478 fail:
39479 return NULL;
39480 }
39481
39482
39483 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39484 PyObject *resultobj = 0;
39485 wxMenu *arg1 = (wxMenu *) 0 ;
39486 size_t arg2 ;
39487 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39488 wxMenuItem *result = 0 ;
39489 void *argp1 = 0 ;
39490 int res1 = 0 ;
39491 size_t val2 ;
39492 int ecode2 = 0 ;
39493 int res3 = 0 ;
39494 PyObject * obj0 = 0 ;
39495 PyObject * obj1 = 0 ;
39496 PyObject * obj2 = 0 ;
39497 char * kwnames[] = {
39498 (char *) "self",(char *) "pos",(char *) "item", NULL
39499 };
39500
39501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39503 if (!SWIG_IsOK(res1)) {
39504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39505 }
39506 arg1 = reinterpret_cast< wxMenu * >(argp1);
39507 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39508 if (!SWIG_IsOK(ecode2)) {
39509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39510 }
39511 arg2 = static_cast< size_t >(val2);
39512 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39513 if (!SWIG_IsOK(res3)) {
39514 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39515 }
39516 {
39517 PyThreadState* __tstate = wxPyBeginAllowThreads();
39518 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 {
39523 resultobj = wxPyMake_wxObject(result, (bool)0);
39524 }
39525 return resultobj;
39526 fail:
39527 return NULL;
39528 }
39529
39530
39531 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39532 PyObject *resultobj = 0;
39533 wxMenu *arg1 = (wxMenu *) 0 ;
39534 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39535 wxMenuItem *result = 0 ;
39536 void *argp1 = 0 ;
39537 int res1 = 0 ;
39538 int res2 = 0 ;
39539 PyObject * obj0 = 0 ;
39540 PyObject * obj1 = 0 ;
39541 char * kwnames[] = {
39542 (char *) "self",(char *) "item", NULL
39543 };
39544
39545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39547 if (!SWIG_IsOK(res1)) {
39548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39549 }
39550 arg1 = reinterpret_cast< wxMenu * >(argp1);
39551 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39552 if (!SWIG_IsOK(res2)) {
39553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39554 }
39555 {
39556 PyThreadState* __tstate = wxPyBeginAllowThreads();
39557 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39558 wxPyEndAllowThreads(__tstate);
39559 if (PyErr_Occurred()) SWIG_fail;
39560 }
39561 {
39562 resultobj = wxPyMake_wxObject(result, (bool)0);
39563 }
39564 return resultobj;
39565 fail:
39566 return NULL;
39567 }
39568
39569
39570 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39571 PyObject *resultobj = 0;
39572 wxMenu *arg1 = (wxMenu *) 0 ;
39573 void *argp1 = 0 ;
39574 int res1 = 0 ;
39575 PyObject *swig_obj[1] ;
39576
39577 if (!args) SWIG_fail;
39578 swig_obj[0] = args;
39579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39580 if (!SWIG_IsOK(res1)) {
39581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39582 }
39583 arg1 = reinterpret_cast< wxMenu * >(argp1);
39584 {
39585 PyThreadState* __tstate = wxPyBeginAllowThreads();
39586 (arg1)->Break();
39587 wxPyEndAllowThreads(__tstate);
39588 if (PyErr_Occurred()) SWIG_fail;
39589 }
39590 resultobj = SWIG_Py_Void();
39591 return resultobj;
39592 fail:
39593 return NULL;
39594 }
39595
39596
39597 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39598 PyObject *resultobj = 0;
39599 wxMenu *arg1 = (wxMenu *) 0 ;
39600 size_t arg2 ;
39601 int arg3 ;
39602 wxString const &arg4_defvalue = wxPyEmptyString ;
39603 wxString *arg4 = (wxString *) &arg4_defvalue ;
39604 wxString const &arg5_defvalue = wxPyEmptyString ;
39605 wxString *arg5 = (wxString *) &arg5_defvalue ;
39606 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39607 wxMenuItem *result = 0 ;
39608 void *argp1 = 0 ;
39609 int res1 = 0 ;
39610 size_t val2 ;
39611 int ecode2 = 0 ;
39612 int val3 ;
39613 int ecode3 = 0 ;
39614 bool temp4 = false ;
39615 bool temp5 = false ;
39616 int val6 ;
39617 int ecode6 = 0 ;
39618 PyObject * obj0 = 0 ;
39619 PyObject * obj1 = 0 ;
39620 PyObject * obj2 = 0 ;
39621 PyObject * obj3 = 0 ;
39622 PyObject * obj4 = 0 ;
39623 PyObject * obj5 = 0 ;
39624 char * kwnames[] = {
39625 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39626 };
39627
39628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39630 if (!SWIG_IsOK(res1)) {
39631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39632 }
39633 arg1 = reinterpret_cast< wxMenu * >(argp1);
39634 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39635 if (!SWIG_IsOK(ecode2)) {
39636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39637 }
39638 arg2 = static_cast< size_t >(val2);
39639 ecode3 = SWIG_AsVal_int(obj2, &val3);
39640 if (!SWIG_IsOK(ecode3)) {
39641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39642 }
39643 arg3 = static_cast< int >(val3);
39644 if (obj3) {
39645 {
39646 arg4 = wxString_in_helper(obj3);
39647 if (arg4 == NULL) SWIG_fail;
39648 temp4 = true;
39649 }
39650 }
39651 if (obj4) {
39652 {
39653 arg5 = wxString_in_helper(obj4);
39654 if (arg5 == NULL) SWIG_fail;
39655 temp5 = true;
39656 }
39657 }
39658 if (obj5) {
39659 ecode6 = SWIG_AsVal_int(obj5, &val6);
39660 if (!SWIG_IsOK(ecode6)) {
39661 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39662 }
39663 arg6 = static_cast< wxItemKind >(val6);
39664 }
39665 {
39666 PyThreadState* __tstate = wxPyBeginAllowThreads();
39667 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39668 wxPyEndAllowThreads(__tstate);
39669 if (PyErr_Occurred()) SWIG_fail;
39670 }
39671 {
39672 resultobj = wxPyMake_wxObject(result, (bool)0);
39673 }
39674 {
39675 if (temp4)
39676 delete arg4;
39677 }
39678 {
39679 if (temp5)
39680 delete arg5;
39681 }
39682 return resultobj;
39683 fail:
39684 {
39685 if (temp4)
39686 delete arg4;
39687 }
39688 {
39689 if (temp5)
39690 delete arg5;
39691 }
39692 return NULL;
39693 }
39694
39695
39696 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39697 PyObject *resultobj = 0;
39698 wxMenu *arg1 = (wxMenu *) 0 ;
39699 size_t arg2 ;
39700 wxMenuItem *result = 0 ;
39701 void *argp1 = 0 ;
39702 int res1 = 0 ;
39703 size_t val2 ;
39704 int ecode2 = 0 ;
39705 PyObject * obj0 = 0 ;
39706 PyObject * obj1 = 0 ;
39707 char * kwnames[] = {
39708 (char *) "self",(char *) "pos", NULL
39709 };
39710
39711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39713 if (!SWIG_IsOK(res1)) {
39714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39715 }
39716 arg1 = reinterpret_cast< wxMenu * >(argp1);
39717 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39718 if (!SWIG_IsOK(ecode2)) {
39719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39720 }
39721 arg2 = static_cast< size_t >(val2);
39722 {
39723 PyThreadState* __tstate = wxPyBeginAllowThreads();
39724 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39725 wxPyEndAllowThreads(__tstate);
39726 if (PyErr_Occurred()) SWIG_fail;
39727 }
39728 {
39729 resultobj = wxPyMake_wxObject(result, (bool)0);
39730 }
39731 return resultobj;
39732 fail:
39733 return NULL;
39734 }
39735
39736
39737 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39738 PyObject *resultobj = 0;
39739 wxMenu *arg1 = (wxMenu *) 0 ;
39740 size_t arg2 ;
39741 int arg3 ;
39742 wxString *arg4 = 0 ;
39743 wxString const &arg5_defvalue = wxPyEmptyString ;
39744 wxString *arg5 = (wxString *) &arg5_defvalue ;
39745 wxMenuItem *result = 0 ;
39746 void *argp1 = 0 ;
39747 int res1 = 0 ;
39748 size_t val2 ;
39749 int ecode2 = 0 ;
39750 int val3 ;
39751 int ecode3 = 0 ;
39752 bool temp4 = false ;
39753 bool temp5 = false ;
39754 PyObject * obj0 = 0 ;
39755 PyObject * obj1 = 0 ;
39756 PyObject * obj2 = 0 ;
39757 PyObject * obj3 = 0 ;
39758 PyObject * obj4 = 0 ;
39759 char * kwnames[] = {
39760 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39761 };
39762
39763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39765 if (!SWIG_IsOK(res1)) {
39766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39767 }
39768 arg1 = reinterpret_cast< wxMenu * >(argp1);
39769 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39770 if (!SWIG_IsOK(ecode2)) {
39771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39772 }
39773 arg2 = static_cast< size_t >(val2);
39774 ecode3 = SWIG_AsVal_int(obj2, &val3);
39775 if (!SWIG_IsOK(ecode3)) {
39776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39777 }
39778 arg3 = static_cast< int >(val3);
39779 {
39780 arg4 = wxString_in_helper(obj3);
39781 if (arg4 == NULL) SWIG_fail;
39782 temp4 = true;
39783 }
39784 if (obj4) {
39785 {
39786 arg5 = wxString_in_helper(obj4);
39787 if (arg5 == NULL) SWIG_fail;
39788 temp5 = true;
39789 }
39790 }
39791 {
39792 PyThreadState* __tstate = wxPyBeginAllowThreads();
39793 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39794 wxPyEndAllowThreads(__tstate);
39795 if (PyErr_Occurred()) SWIG_fail;
39796 }
39797 {
39798 resultobj = wxPyMake_wxObject(result, (bool)0);
39799 }
39800 {
39801 if (temp4)
39802 delete arg4;
39803 }
39804 {
39805 if (temp5)
39806 delete arg5;
39807 }
39808 return resultobj;
39809 fail:
39810 {
39811 if (temp4)
39812 delete arg4;
39813 }
39814 {
39815 if (temp5)
39816 delete arg5;
39817 }
39818 return NULL;
39819 }
39820
39821
39822 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39823 PyObject *resultobj = 0;
39824 wxMenu *arg1 = (wxMenu *) 0 ;
39825 size_t arg2 ;
39826 int arg3 ;
39827 wxString *arg4 = 0 ;
39828 wxString const &arg5_defvalue = wxPyEmptyString ;
39829 wxString *arg5 = (wxString *) &arg5_defvalue ;
39830 wxMenuItem *result = 0 ;
39831 void *argp1 = 0 ;
39832 int res1 = 0 ;
39833 size_t val2 ;
39834 int ecode2 = 0 ;
39835 int val3 ;
39836 int ecode3 = 0 ;
39837 bool temp4 = false ;
39838 bool temp5 = false ;
39839 PyObject * obj0 = 0 ;
39840 PyObject * obj1 = 0 ;
39841 PyObject * obj2 = 0 ;
39842 PyObject * obj3 = 0 ;
39843 PyObject * obj4 = 0 ;
39844 char * kwnames[] = {
39845 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39846 };
39847
39848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39850 if (!SWIG_IsOK(res1)) {
39851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39852 }
39853 arg1 = reinterpret_cast< wxMenu * >(argp1);
39854 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39855 if (!SWIG_IsOK(ecode2)) {
39856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39857 }
39858 arg2 = static_cast< size_t >(val2);
39859 ecode3 = SWIG_AsVal_int(obj2, &val3);
39860 if (!SWIG_IsOK(ecode3)) {
39861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39862 }
39863 arg3 = static_cast< int >(val3);
39864 {
39865 arg4 = wxString_in_helper(obj3);
39866 if (arg4 == NULL) SWIG_fail;
39867 temp4 = true;
39868 }
39869 if (obj4) {
39870 {
39871 arg5 = wxString_in_helper(obj4);
39872 if (arg5 == NULL) SWIG_fail;
39873 temp5 = true;
39874 }
39875 }
39876 {
39877 PyThreadState* __tstate = wxPyBeginAllowThreads();
39878 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39879 wxPyEndAllowThreads(__tstate);
39880 if (PyErr_Occurred()) SWIG_fail;
39881 }
39882 {
39883 resultobj = wxPyMake_wxObject(result, (bool)0);
39884 }
39885 {
39886 if (temp4)
39887 delete arg4;
39888 }
39889 {
39890 if (temp5)
39891 delete arg5;
39892 }
39893 return resultobj;
39894 fail:
39895 {
39896 if (temp4)
39897 delete arg4;
39898 }
39899 {
39900 if (temp5)
39901 delete arg5;
39902 }
39903 return NULL;
39904 }
39905
39906
39907 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39908 PyObject *resultobj = 0;
39909 wxMenu *arg1 = (wxMenu *) 0 ;
39910 size_t arg2 ;
39911 int arg3 ;
39912 wxString *arg4 = 0 ;
39913 wxMenu *arg5 = (wxMenu *) 0 ;
39914 wxString const &arg6_defvalue = wxPyEmptyString ;
39915 wxString *arg6 = (wxString *) &arg6_defvalue ;
39916 wxMenuItem *result = 0 ;
39917 void *argp1 = 0 ;
39918 int res1 = 0 ;
39919 size_t val2 ;
39920 int ecode2 = 0 ;
39921 int val3 ;
39922 int ecode3 = 0 ;
39923 bool temp4 = false ;
39924 void *argp5 = 0 ;
39925 int res5 = 0 ;
39926 bool temp6 = false ;
39927 PyObject * obj0 = 0 ;
39928 PyObject * obj1 = 0 ;
39929 PyObject * obj2 = 0 ;
39930 PyObject * obj3 = 0 ;
39931 PyObject * obj4 = 0 ;
39932 PyObject * obj5 = 0 ;
39933 char * kwnames[] = {
39934 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39935 };
39936
39937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39939 if (!SWIG_IsOK(res1)) {
39940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39941 }
39942 arg1 = reinterpret_cast< wxMenu * >(argp1);
39943 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39944 if (!SWIG_IsOK(ecode2)) {
39945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39946 }
39947 arg2 = static_cast< size_t >(val2);
39948 ecode3 = SWIG_AsVal_int(obj2, &val3);
39949 if (!SWIG_IsOK(ecode3)) {
39950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39951 }
39952 arg3 = static_cast< int >(val3);
39953 {
39954 arg4 = wxString_in_helper(obj3);
39955 if (arg4 == NULL) SWIG_fail;
39956 temp4 = true;
39957 }
39958 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39959 if (!SWIG_IsOK(res5)) {
39960 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39961 }
39962 arg5 = reinterpret_cast< wxMenu * >(argp5);
39963 if (obj5) {
39964 {
39965 arg6 = wxString_in_helper(obj5);
39966 if (arg6 == NULL) SWIG_fail;
39967 temp6 = true;
39968 }
39969 }
39970 {
39971 PyThreadState* __tstate = wxPyBeginAllowThreads();
39972 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39973 wxPyEndAllowThreads(__tstate);
39974 if (PyErr_Occurred()) SWIG_fail;
39975 }
39976 {
39977 resultobj = wxPyMake_wxObject(result, (bool)0);
39978 }
39979 {
39980 if (temp4)
39981 delete arg4;
39982 }
39983 {
39984 if (temp6)
39985 delete arg6;
39986 }
39987 return resultobj;
39988 fail:
39989 {
39990 if (temp4)
39991 delete arg4;
39992 }
39993 {
39994 if (temp6)
39995 delete arg6;
39996 }
39997 return NULL;
39998 }
39999
40000
40001 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40002 PyObject *resultobj = 0;
40003 wxMenu *arg1 = (wxMenu *) 0 ;
40004 int arg2 ;
40005 wxString const &arg3_defvalue = wxPyEmptyString ;
40006 wxString *arg3 = (wxString *) &arg3_defvalue ;
40007 wxString const &arg4_defvalue = wxPyEmptyString ;
40008 wxString *arg4 = (wxString *) &arg4_defvalue ;
40009 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40010 wxMenuItem *result = 0 ;
40011 void *argp1 = 0 ;
40012 int res1 = 0 ;
40013 int val2 ;
40014 int ecode2 = 0 ;
40015 bool temp3 = false ;
40016 bool temp4 = false ;
40017 int val5 ;
40018 int ecode5 = 0 ;
40019 PyObject * obj0 = 0 ;
40020 PyObject * obj1 = 0 ;
40021 PyObject * obj2 = 0 ;
40022 PyObject * obj3 = 0 ;
40023 PyObject * obj4 = 0 ;
40024 char * kwnames[] = {
40025 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40026 };
40027
40028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40030 if (!SWIG_IsOK(res1)) {
40031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40032 }
40033 arg1 = reinterpret_cast< wxMenu * >(argp1);
40034 ecode2 = SWIG_AsVal_int(obj1, &val2);
40035 if (!SWIG_IsOK(ecode2)) {
40036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40037 }
40038 arg2 = static_cast< int >(val2);
40039 if (obj2) {
40040 {
40041 arg3 = wxString_in_helper(obj2);
40042 if (arg3 == NULL) SWIG_fail;
40043 temp3 = true;
40044 }
40045 }
40046 if (obj3) {
40047 {
40048 arg4 = wxString_in_helper(obj3);
40049 if (arg4 == NULL) SWIG_fail;
40050 temp4 = true;
40051 }
40052 }
40053 if (obj4) {
40054 ecode5 = SWIG_AsVal_int(obj4, &val5);
40055 if (!SWIG_IsOK(ecode5)) {
40056 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40057 }
40058 arg5 = static_cast< wxItemKind >(val5);
40059 }
40060 {
40061 PyThreadState* __tstate = wxPyBeginAllowThreads();
40062 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40063 wxPyEndAllowThreads(__tstate);
40064 if (PyErr_Occurred()) SWIG_fail;
40065 }
40066 {
40067 resultobj = wxPyMake_wxObject(result, (bool)0);
40068 }
40069 {
40070 if (temp3)
40071 delete arg3;
40072 }
40073 {
40074 if (temp4)
40075 delete arg4;
40076 }
40077 return resultobj;
40078 fail:
40079 {
40080 if (temp3)
40081 delete arg3;
40082 }
40083 {
40084 if (temp4)
40085 delete arg4;
40086 }
40087 return NULL;
40088 }
40089
40090
40091 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40092 PyObject *resultobj = 0;
40093 wxMenu *arg1 = (wxMenu *) 0 ;
40094 wxMenuItem *result = 0 ;
40095 void *argp1 = 0 ;
40096 int res1 = 0 ;
40097 PyObject *swig_obj[1] ;
40098
40099 if (!args) SWIG_fail;
40100 swig_obj[0] = args;
40101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40102 if (!SWIG_IsOK(res1)) {
40103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40104 }
40105 arg1 = reinterpret_cast< wxMenu * >(argp1);
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 result = (wxMenuItem *)(arg1)->PrependSeparator();
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 resultobj = wxPyMake_wxObject(result, (bool)0);
40114 }
40115 return resultobj;
40116 fail:
40117 return NULL;
40118 }
40119
40120
40121 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40122 PyObject *resultobj = 0;
40123 wxMenu *arg1 = (wxMenu *) 0 ;
40124 int arg2 ;
40125 wxString *arg3 = 0 ;
40126 wxString const &arg4_defvalue = wxPyEmptyString ;
40127 wxString *arg4 = (wxString *) &arg4_defvalue ;
40128 wxMenuItem *result = 0 ;
40129 void *argp1 = 0 ;
40130 int res1 = 0 ;
40131 int val2 ;
40132 int ecode2 = 0 ;
40133 bool temp3 = false ;
40134 bool temp4 = false ;
40135 PyObject * obj0 = 0 ;
40136 PyObject * obj1 = 0 ;
40137 PyObject * obj2 = 0 ;
40138 PyObject * obj3 = 0 ;
40139 char * kwnames[] = {
40140 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40141 };
40142
40143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40147 }
40148 arg1 = reinterpret_cast< wxMenu * >(argp1);
40149 ecode2 = SWIG_AsVal_int(obj1, &val2);
40150 if (!SWIG_IsOK(ecode2)) {
40151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40152 }
40153 arg2 = static_cast< int >(val2);
40154 {
40155 arg3 = wxString_in_helper(obj2);
40156 if (arg3 == NULL) SWIG_fail;
40157 temp3 = true;
40158 }
40159 if (obj3) {
40160 {
40161 arg4 = wxString_in_helper(obj3);
40162 if (arg4 == NULL) SWIG_fail;
40163 temp4 = true;
40164 }
40165 }
40166 {
40167 PyThreadState* __tstate = wxPyBeginAllowThreads();
40168 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 {
40173 resultobj = wxPyMake_wxObject(result, (bool)0);
40174 }
40175 {
40176 if (temp3)
40177 delete arg3;
40178 }
40179 {
40180 if (temp4)
40181 delete arg4;
40182 }
40183 return resultobj;
40184 fail:
40185 {
40186 if (temp3)
40187 delete arg3;
40188 }
40189 {
40190 if (temp4)
40191 delete arg4;
40192 }
40193 return NULL;
40194 }
40195
40196
40197 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj = 0;
40199 wxMenu *arg1 = (wxMenu *) 0 ;
40200 int arg2 ;
40201 wxString *arg3 = 0 ;
40202 wxString const &arg4_defvalue = wxPyEmptyString ;
40203 wxString *arg4 = (wxString *) &arg4_defvalue ;
40204 wxMenuItem *result = 0 ;
40205 void *argp1 = 0 ;
40206 int res1 = 0 ;
40207 int val2 ;
40208 int ecode2 = 0 ;
40209 bool temp3 = false ;
40210 bool temp4 = false ;
40211 PyObject * obj0 = 0 ;
40212 PyObject * obj1 = 0 ;
40213 PyObject * obj2 = 0 ;
40214 PyObject * obj3 = 0 ;
40215 char * kwnames[] = {
40216 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40217 };
40218
40219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40221 if (!SWIG_IsOK(res1)) {
40222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40223 }
40224 arg1 = reinterpret_cast< wxMenu * >(argp1);
40225 ecode2 = SWIG_AsVal_int(obj1, &val2);
40226 if (!SWIG_IsOK(ecode2)) {
40227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40228 }
40229 arg2 = static_cast< int >(val2);
40230 {
40231 arg3 = wxString_in_helper(obj2);
40232 if (arg3 == NULL) SWIG_fail;
40233 temp3 = true;
40234 }
40235 if (obj3) {
40236 {
40237 arg4 = wxString_in_helper(obj3);
40238 if (arg4 == NULL) SWIG_fail;
40239 temp4 = true;
40240 }
40241 }
40242 {
40243 PyThreadState* __tstate = wxPyBeginAllowThreads();
40244 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 {
40249 resultobj = wxPyMake_wxObject(result, (bool)0);
40250 }
40251 {
40252 if (temp3)
40253 delete arg3;
40254 }
40255 {
40256 if (temp4)
40257 delete arg4;
40258 }
40259 return resultobj;
40260 fail:
40261 {
40262 if (temp3)
40263 delete arg3;
40264 }
40265 {
40266 if (temp4)
40267 delete arg4;
40268 }
40269 return NULL;
40270 }
40271
40272
40273 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj = 0;
40275 wxMenu *arg1 = (wxMenu *) 0 ;
40276 int arg2 ;
40277 wxString *arg3 = 0 ;
40278 wxMenu *arg4 = (wxMenu *) 0 ;
40279 wxString const &arg5_defvalue = wxPyEmptyString ;
40280 wxString *arg5 = (wxString *) &arg5_defvalue ;
40281 wxMenuItem *result = 0 ;
40282 void *argp1 = 0 ;
40283 int res1 = 0 ;
40284 int val2 ;
40285 int ecode2 = 0 ;
40286 bool temp3 = false ;
40287 void *argp4 = 0 ;
40288 int res4 = 0 ;
40289 bool temp5 = false ;
40290 PyObject * obj0 = 0 ;
40291 PyObject * obj1 = 0 ;
40292 PyObject * obj2 = 0 ;
40293 PyObject * obj3 = 0 ;
40294 PyObject * obj4 = 0 ;
40295 char * kwnames[] = {
40296 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40297 };
40298
40299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40301 if (!SWIG_IsOK(res1)) {
40302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40303 }
40304 arg1 = reinterpret_cast< wxMenu * >(argp1);
40305 ecode2 = SWIG_AsVal_int(obj1, &val2);
40306 if (!SWIG_IsOK(ecode2)) {
40307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40308 }
40309 arg2 = static_cast< int >(val2);
40310 {
40311 arg3 = wxString_in_helper(obj2);
40312 if (arg3 == NULL) SWIG_fail;
40313 temp3 = true;
40314 }
40315 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40316 if (!SWIG_IsOK(res4)) {
40317 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40318 }
40319 arg4 = reinterpret_cast< wxMenu * >(argp4);
40320 if (obj4) {
40321 {
40322 arg5 = wxString_in_helper(obj4);
40323 if (arg5 == NULL) SWIG_fail;
40324 temp5 = true;
40325 }
40326 }
40327 {
40328 PyThreadState* __tstate = wxPyBeginAllowThreads();
40329 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40330 wxPyEndAllowThreads(__tstate);
40331 if (PyErr_Occurred()) SWIG_fail;
40332 }
40333 {
40334 resultobj = wxPyMake_wxObject(result, (bool)0);
40335 }
40336 {
40337 if (temp3)
40338 delete arg3;
40339 }
40340 {
40341 if (temp5)
40342 delete arg5;
40343 }
40344 return resultobj;
40345 fail:
40346 {
40347 if (temp3)
40348 delete arg3;
40349 }
40350 {
40351 if (temp5)
40352 delete arg5;
40353 }
40354 return NULL;
40355 }
40356
40357
40358 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40359 PyObject *resultobj = 0;
40360 wxMenu *arg1 = (wxMenu *) 0 ;
40361 int arg2 ;
40362 wxMenuItem *result = 0 ;
40363 void *argp1 = 0 ;
40364 int res1 = 0 ;
40365 int val2 ;
40366 int ecode2 = 0 ;
40367 PyObject * obj0 = 0 ;
40368 PyObject * obj1 = 0 ;
40369 char * kwnames[] = {
40370 (char *) "self",(char *) "id", NULL
40371 };
40372
40373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40375 if (!SWIG_IsOK(res1)) {
40376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40377 }
40378 arg1 = reinterpret_cast< wxMenu * >(argp1);
40379 ecode2 = SWIG_AsVal_int(obj1, &val2);
40380 if (!SWIG_IsOK(ecode2)) {
40381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40382 }
40383 arg2 = static_cast< int >(val2);
40384 {
40385 PyThreadState* __tstate = wxPyBeginAllowThreads();
40386 result = (wxMenuItem *)(arg1)->Remove(arg2);
40387 wxPyEndAllowThreads(__tstate);
40388 if (PyErr_Occurred()) SWIG_fail;
40389 }
40390 {
40391 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40392 }
40393 return resultobj;
40394 fail:
40395 return NULL;
40396 }
40397
40398
40399 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40400 PyObject *resultobj = 0;
40401 wxMenu *arg1 = (wxMenu *) 0 ;
40402 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40403 wxMenuItem *result = 0 ;
40404 void *argp1 = 0 ;
40405 int res1 = 0 ;
40406 void *argp2 = 0 ;
40407 int res2 = 0 ;
40408 PyObject * obj0 = 0 ;
40409 PyObject * obj1 = 0 ;
40410 char * kwnames[] = {
40411 (char *) "self",(char *) "item", NULL
40412 };
40413
40414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40416 if (!SWIG_IsOK(res1)) {
40417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40418 }
40419 arg1 = reinterpret_cast< wxMenu * >(argp1);
40420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40421 if (!SWIG_IsOK(res2)) {
40422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40423 }
40424 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 result = (wxMenuItem *)(arg1)->Remove(arg2);
40428 wxPyEndAllowThreads(__tstate);
40429 if (PyErr_Occurred()) SWIG_fail;
40430 }
40431 {
40432 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40433 }
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40441 PyObject *resultobj = 0;
40442 wxMenu *arg1 = (wxMenu *) 0 ;
40443 int arg2 ;
40444 bool result;
40445 void *argp1 = 0 ;
40446 int res1 = 0 ;
40447 int val2 ;
40448 int ecode2 = 0 ;
40449 PyObject * obj0 = 0 ;
40450 PyObject * obj1 = 0 ;
40451 char * kwnames[] = {
40452 (char *) "self",(char *) "id", NULL
40453 };
40454
40455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40457 if (!SWIG_IsOK(res1)) {
40458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40459 }
40460 arg1 = reinterpret_cast< wxMenu * >(argp1);
40461 ecode2 = SWIG_AsVal_int(obj1, &val2);
40462 if (!SWIG_IsOK(ecode2)) {
40463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40464 }
40465 arg2 = static_cast< int >(val2);
40466 {
40467 PyThreadState* __tstate = wxPyBeginAllowThreads();
40468 result = (bool)(arg1)->Delete(arg2);
40469 wxPyEndAllowThreads(__tstate);
40470 if (PyErr_Occurred()) SWIG_fail;
40471 }
40472 {
40473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40474 }
40475 return resultobj;
40476 fail:
40477 return NULL;
40478 }
40479
40480
40481 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40482 PyObject *resultobj = 0;
40483 wxMenu *arg1 = (wxMenu *) 0 ;
40484 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40485 bool result;
40486 void *argp1 = 0 ;
40487 int res1 = 0 ;
40488 void *argp2 = 0 ;
40489 int res2 = 0 ;
40490 PyObject * obj0 = 0 ;
40491 PyObject * obj1 = 0 ;
40492 char * kwnames[] = {
40493 (char *) "self",(char *) "item", NULL
40494 };
40495
40496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40498 if (!SWIG_IsOK(res1)) {
40499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40500 }
40501 arg1 = reinterpret_cast< wxMenu * >(argp1);
40502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40503 if (!SWIG_IsOK(res2)) {
40504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40505 }
40506 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40507 {
40508 PyThreadState* __tstate = wxPyBeginAllowThreads();
40509 result = (bool)(arg1)->Delete(arg2);
40510 wxPyEndAllowThreads(__tstate);
40511 if (PyErr_Occurred()) SWIG_fail;
40512 }
40513 {
40514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40515 }
40516 return resultobj;
40517 fail:
40518 return NULL;
40519 }
40520
40521
40522 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40523 PyObject *resultobj = 0;
40524 wxMenu *arg1 = (wxMenu *) 0 ;
40525 void *argp1 = 0 ;
40526 int res1 = 0 ;
40527 PyObject *swig_obj[1] ;
40528
40529 if (!args) SWIG_fail;
40530 swig_obj[0] = args;
40531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40532 if (!SWIG_IsOK(res1)) {
40533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40534 }
40535 arg1 = reinterpret_cast< wxMenu * >(argp1);
40536 {
40537 PyThreadState* __tstate = wxPyBeginAllowThreads();
40538 wxMenu_Destroy(arg1);
40539 wxPyEndAllowThreads(__tstate);
40540 if (PyErr_Occurred()) SWIG_fail;
40541 }
40542 resultobj = SWIG_Py_Void();
40543 return resultobj;
40544 fail:
40545 return NULL;
40546 }
40547
40548
40549 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40550 PyObject *resultobj = 0;
40551 wxMenu *arg1 = (wxMenu *) 0 ;
40552 int arg2 ;
40553 bool result;
40554 void *argp1 = 0 ;
40555 int res1 = 0 ;
40556 int val2 ;
40557 int ecode2 = 0 ;
40558 PyObject * obj0 = 0 ;
40559 PyObject * obj1 = 0 ;
40560 char * kwnames[] = {
40561 (char *) "self",(char *) "id", NULL
40562 };
40563
40564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40566 if (!SWIG_IsOK(res1)) {
40567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40568 }
40569 arg1 = reinterpret_cast< wxMenu * >(argp1);
40570 ecode2 = SWIG_AsVal_int(obj1, &val2);
40571 if (!SWIG_IsOK(ecode2)) {
40572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40573 }
40574 arg2 = static_cast< int >(val2);
40575 {
40576 PyThreadState* __tstate = wxPyBeginAllowThreads();
40577 result = (bool)(arg1)->Destroy(arg2);
40578 wxPyEndAllowThreads(__tstate);
40579 if (PyErr_Occurred()) SWIG_fail;
40580 }
40581 {
40582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40583 }
40584 return resultobj;
40585 fail:
40586 return NULL;
40587 }
40588
40589
40590 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40591 PyObject *resultobj = 0;
40592 wxMenu *arg1 = (wxMenu *) 0 ;
40593 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40594 bool result;
40595 void *argp1 = 0 ;
40596 int res1 = 0 ;
40597 void *argp2 = 0 ;
40598 int res2 = 0 ;
40599 PyObject * obj0 = 0 ;
40600 PyObject * obj1 = 0 ;
40601 char * kwnames[] = {
40602 (char *) "self",(char *) "item", NULL
40603 };
40604
40605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40607 if (!SWIG_IsOK(res1)) {
40608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40609 }
40610 arg1 = reinterpret_cast< wxMenu * >(argp1);
40611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40612 if (!SWIG_IsOK(res2)) {
40613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40614 }
40615 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 result = (bool)(arg1)->Destroy(arg2);
40619 wxPyEndAllowThreads(__tstate);
40620 if (PyErr_Occurred()) SWIG_fail;
40621 }
40622 {
40623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40624 }
40625 return resultobj;
40626 fail:
40627 return NULL;
40628 }
40629
40630
40631 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40632 PyObject *resultobj = 0;
40633 wxMenu *arg1 = (wxMenu *) 0 ;
40634 size_t result;
40635 void *argp1 = 0 ;
40636 int res1 = 0 ;
40637 PyObject *swig_obj[1] ;
40638
40639 if (!args) SWIG_fail;
40640 swig_obj[0] = args;
40641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40642 if (!SWIG_IsOK(res1)) {
40643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40644 }
40645 arg1 = reinterpret_cast< wxMenu * >(argp1);
40646 {
40647 PyThreadState* __tstate = wxPyBeginAllowThreads();
40648 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40649 wxPyEndAllowThreads(__tstate);
40650 if (PyErr_Occurred()) SWIG_fail;
40651 }
40652 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40653 return resultobj;
40654 fail:
40655 return NULL;
40656 }
40657
40658
40659 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40660 PyObject *resultobj = 0;
40661 wxMenu *arg1 = (wxMenu *) 0 ;
40662 PyObject *result = 0 ;
40663 void *argp1 = 0 ;
40664 int res1 = 0 ;
40665 PyObject *swig_obj[1] ;
40666
40667 if (!args) SWIG_fail;
40668 swig_obj[0] = args;
40669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40670 if (!SWIG_IsOK(res1)) {
40671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40672 }
40673 arg1 = reinterpret_cast< wxMenu * >(argp1);
40674 {
40675 PyThreadState* __tstate = wxPyBeginAllowThreads();
40676 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40677 wxPyEndAllowThreads(__tstate);
40678 if (PyErr_Occurred()) SWIG_fail;
40679 }
40680 resultobj = result;
40681 return resultobj;
40682 fail:
40683 return NULL;
40684 }
40685
40686
40687 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40688 PyObject *resultobj = 0;
40689 wxMenu *arg1 = (wxMenu *) 0 ;
40690 wxString *arg2 = 0 ;
40691 int result;
40692 void *argp1 = 0 ;
40693 int res1 = 0 ;
40694 bool temp2 = false ;
40695 PyObject * obj0 = 0 ;
40696 PyObject * obj1 = 0 ;
40697 char * kwnames[] = {
40698 (char *) "self",(char *) "item", NULL
40699 };
40700
40701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40703 if (!SWIG_IsOK(res1)) {
40704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40705 }
40706 arg1 = reinterpret_cast< wxMenu * >(argp1);
40707 {
40708 arg2 = wxString_in_helper(obj1);
40709 if (arg2 == NULL) SWIG_fail;
40710 temp2 = true;
40711 }
40712 {
40713 PyThreadState* __tstate = wxPyBeginAllowThreads();
40714 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40715 wxPyEndAllowThreads(__tstate);
40716 if (PyErr_Occurred()) SWIG_fail;
40717 }
40718 resultobj = SWIG_From_int(static_cast< int >(result));
40719 {
40720 if (temp2)
40721 delete arg2;
40722 }
40723 return resultobj;
40724 fail:
40725 {
40726 if (temp2)
40727 delete arg2;
40728 }
40729 return NULL;
40730 }
40731
40732
40733 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40734 PyObject *resultobj = 0;
40735 wxMenu *arg1 = (wxMenu *) 0 ;
40736 int arg2 ;
40737 wxMenuItem *result = 0 ;
40738 void *argp1 = 0 ;
40739 int res1 = 0 ;
40740 int val2 ;
40741 int ecode2 = 0 ;
40742 PyObject * obj0 = 0 ;
40743 PyObject * obj1 = 0 ;
40744 char * kwnames[] = {
40745 (char *) "self",(char *) "id", NULL
40746 };
40747
40748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40750 if (!SWIG_IsOK(res1)) {
40751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40752 }
40753 arg1 = reinterpret_cast< wxMenu * >(argp1);
40754 ecode2 = SWIG_AsVal_int(obj1, &val2);
40755 if (!SWIG_IsOK(ecode2)) {
40756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40757 }
40758 arg2 = static_cast< int >(val2);
40759 {
40760 PyThreadState* __tstate = wxPyBeginAllowThreads();
40761 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40762 wxPyEndAllowThreads(__tstate);
40763 if (PyErr_Occurred()) SWIG_fail;
40764 }
40765 {
40766 resultobj = wxPyMake_wxObject(result, (bool)0);
40767 }
40768 return resultobj;
40769 fail:
40770 return NULL;
40771 }
40772
40773
40774 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40775 PyObject *resultobj = 0;
40776 wxMenu *arg1 = (wxMenu *) 0 ;
40777 size_t arg2 ;
40778 wxMenuItem *result = 0 ;
40779 void *argp1 = 0 ;
40780 int res1 = 0 ;
40781 size_t val2 ;
40782 int ecode2 = 0 ;
40783 PyObject * obj0 = 0 ;
40784 PyObject * obj1 = 0 ;
40785 char * kwnames[] = {
40786 (char *) "self",(char *) "position", NULL
40787 };
40788
40789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40791 if (!SWIG_IsOK(res1)) {
40792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40793 }
40794 arg1 = reinterpret_cast< wxMenu * >(argp1);
40795 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40796 if (!SWIG_IsOK(ecode2)) {
40797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40798 }
40799 arg2 = static_cast< size_t >(val2);
40800 {
40801 PyThreadState* __tstate = wxPyBeginAllowThreads();
40802 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40803 wxPyEndAllowThreads(__tstate);
40804 if (PyErr_Occurred()) SWIG_fail;
40805 }
40806 {
40807 resultobj = wxPyMake_wxObject(result, (bool)0);
40808 }
40809 return resultobj;
40810 fail:
40811 return NULL;
40812 }
40813
40814
40815 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40816 PyObject *resultobj = 0;
40817 wxMenu *arg1 = (wxMenu *) 0 ;
40818 int arg2 ;
40819 bool arg3 ;
40820 void *argp1 = 0 ;
40821 int res1 = 0 ;
40822 int val2 ;
40823 int ecode2 = 0 ;
40824 bool val3 ;
40825 int ecode3 = 0 ;
40826 PyObject * obj0 = 0 ;
40827 PyObject * obj1 = 0 ;
40828 PyObject * obj2 = 0 ;
40829 char * kwnames[] = {
40830 (char *) "self",(char *) "id",(char *) "enable", NULL
40831 };
40832
40833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40835 if (!SWIG_IsOK(res1)) {
40836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40837 }
40838 arg1 = reinterpret_cast< wxMenu * >(argp1);
40839 ecode2 = SWIG_AsVal_int(obj1, &val2);
40840 if (!SWIG_IsOK(ecode2)) {
40841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40842 }
40843 arg2 = static_cast< int >(val2);
40844 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40845 if (!SWIG_IsOK(ecode3)) {
40846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40847 }
40848 arg3 = static_cast< bool >(val3);
40849 {
40850 PyThreadState* __tstate = wxPyBeginAllowThreads();
40851 (arg1)->Enable(arg2,arg3);
40852 wxPyEndAllowThreads(__tstate);
40853 if (PyErr_Occurred()) SWIG_fail;
40854 }
40855 resultobj = SWIG_Py_Void();
40856 return resultobj;
40857 fail:
40858 return NULL;
40859 }
40860
40861
40862 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40863 PyObject *resultobj = 0;
40864 wxMenu *arg1 = (wxMenu *) 0 ;
40865 int arg2 ;
40866 bool result;
40867 void *argp1 = 0 ;
40868 int res1 = 0 ;
40869 int val2 ;
40870 int ecode2 = 0 ;
40871 PyObject * obj0 = 0 ;
40872 PyObject * obj1 = 0 ;
40873 char * kwnames[] = {
40874 (char *) "self",(char *) "id", NULL
40875 };
40876
40877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40879 if (!SWIG_IsOK(res1)) {
40880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40881 }
40882 arg1 = reinterpret_cast< wxMenu * >(argp1);
40883 ecode2 = SWIG_AsVal_int(obj1, &val2);
40884 if (!SWIG_IsOK(ecode2)) {
40885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40886 }
40887 arg2 = static_cast< int >(val2);
40888 {
40889 PyThreadState* __tstate = wxPyBeginAllowThreads();
40890 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40891 wxPyEndAllowThreads(__tstate);
40892 if (PyErr_Occurred()) SWIG_fail;
40893 }
40894 {
40895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40896 }
40897 return resultobj;
40898 fail:
40899 return NULL;
40900 }
40901
40902
40903 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40904 PyObject *resultobj = 0;
40905 wxMenu *arg1 = (wxMenu *) 0 ;
40906 int arg2 ;
40907 bool arg3 ;
40908 void *argp1 = 0 ;
40909 int res1 = 0 ;
40910 int val2 ;
40911 int ecode2 = 0 ;
40912 bool val3 ;
40913 int ecode3 = 0 ;
40914 PyObject * obj0 = 0 ;
40915 PyObject * obj1 = 0 ;
40916 PyObject * obj2 = 0 ;
40917 char * kwnames[] = {
40918 (char *) "self",(char *) "id",(char *) "check", NULL
40919 };
40920
40921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40923 if (!SWIG_IsOK(res1)) {
40924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40925 }
40926 arg1 = reinterpret_cast< wxMenu * >(argp1);
40927 ecode2 = SWIG_AsVal_int(obj1, &val2);
40928 if (!SWIG_IsOK(ecode2)) {
40929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40930 }
40931 arg2 = static_cast< int >(val2);
40932 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40933 if (!SWIG_IsOK(ecode3)) {
40934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40935 }
40936 arg3 = static_cast< bool >(val3);
40937 {
40938 PyThreadState* __tstate = wxPyBeginAllowThreads();
40939 (arg1)->Check(arg2,arg3);
40940 wxPyEndAllowThreads(__tstate);
40941 if (PyErr_Occurred()) SWIG_fail;
40942 }
40943 resultobj = SWIG_Py_Void();
40944 return resultobj;
40945 fail:
40946 return NULL;
40947 }
40948
40949
40950 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40951 PyObject *resultobj = 0;
40952 wxMenu *arg1 = (wxMenu *) 0 ;
40953 int arg2 ;
40954 bool result;
40955 void *argp1 = 0 ;
40956 int res1 = 0 ;
40957 int val2 ;
40958 int ecode2 = 0 ;
40959 PyObject * obj0 = 0 ;
40960 PyObject * obj1 = 0 ;
40961 char * kwnames[] = {
40962 (char *) "self",(char *) "id", NULL
40963 };
40964
40965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40967 if (!SWIG_IsOK(res1)) {
40968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40969 }
40970 arg1 = reinterpret_cast< wxMenu * >(argp1);
40971 ecode2 = SWIG_AsVal_int(obj1, &val2);
40972 if (!SWIG_IsOK(ecode2)) {
40973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40974 }
40975 arg2 = static_cast< int >(val2);
40976 {
40977 PyThreadState* __tstate = wxPyBeginAllowThreads();
40978 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40979 wxPyEndAllowThreads(__tstate);
40980 if (PyErr_Occurred()) SWIG_fail;
40981 }
40982 {
40983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40984 }
40985 return resultobj;
40986 fail:
40987 return NULL;
40988 }
40989
40990
40991 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40992 PyObject *resultobj = 0;
40993 wxMenu *arg1 = (wxMenu *) 0 ;
40994 int arg2 ;
40995 wxString *arg3 = 0 ;
40996 void *argp1 = 0 ;
40997 int res1 = 0 ;
40998 int val2 ;
40999 int ecode2 = 0 ;
41000 bool temp3 = false ;
41001 PyObject * obj0 = 0 ;
41002 PyObject * obj1 = 0 ;
41003 PyObject * obj2 = 0 ;
41004 char * kwnames[] = {
41005 (char *) "self",(char *) "id",(char *) "label", NULL
41006 };
41007
41008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41010 if (!SWIG_IsOK(res1)) {
41011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41012 }
41013 arg1 = reinterpret_cast< wxMenu * >(argp1);
41014 ecode2 = SWIG_AsVal_int(obj1, &val2);
41015 if (!SWIG_IsOK(ecode2)) {
41016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41017 }
41018 arg2 = static_cast< int >(val2);
41019 {
41020 arg3 = wxString_in_helper(obj2);
41021 if (arg3 == NULL) SWIG_fail;
41022 temp3 = true;
41023 }
41024 {
41025 PyThreadState* __tstate = wxPyBeginAllowThreads();
41026 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41027 wxPyEndAllowThreads(__tstate);
41028 if (PyErr_Occurred()) SWIG_fail;
41029 }
41030 resultobj = SWIG_Py_Void();
41031 {
41032 if (temp3)
41033 delete arg3;
41034 }
41035 return resultobj;
41036 fail:
41037 {
41038 if (temp3)
41039 delete arg3;
41040 }
41041 return NULL;
41042 }
41043
41044
41045 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41046 PyObject *resultobj = 0;
41047 wxMenu *arg1 = (wxMenu *) 0 ;
41048 int arg2 ;
41049 wxString result;
41050 void *argp1 = 0 ;
41051 int res1 = 0 ;
41052 int val2 ;
41053 int ecode2 = 0 ;
41054 PyObject * obj0 = 0 ;
41055 PyObject * obj1 = 0 ;
41056 char * kwnames[] = {
41057 (char *) "self",(char *) "id", NULL
41058 };
41059
41060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41062 if (!SWIG_IsOK(res1)) {
41063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41064 }
41065 arg1 = reinterpret_cast< wxMenu * >(argp1);
41066 ecode2 = SWIG_AsVal_int(obj1, &val2);
41067 if (!SWIG_IsOK(ecode2)) {
41068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41069 }
41070 arg2 = static_cast< int >(val2);
41071 {
41072 PyThreadState* __tstate = wxPyBeginAllowThreads();
41073 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41074 wxPyEndAllowThreads(__tstate);
41075 if (PyErr_Occurred()) SWIG_fail;
41076 }
41077 {
41078 #if wxUSE_UNICODE
41079 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41080 #else
41081 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41082 #endif
41083 }
41084 return resultobj;
41085 fail:
41086 return NULL;
41087 }
41088
41089
41090 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41091 PyObject *resultobj = 0;
41092 wxMenu *arg1 = (wxMenu *) 0 ;
41093 int arg2 ;
41094 wxString *arg3 = 0 ;
41095 void *argp1 = 0 ;
41096 int res1 = 0 ;
41097 int val2 ;
41098 int ecode2 = 0 ;
41099 bool temp3 = false ;
41100 PyObject * obj0 = 0 ;
41101 PyObject * obj1 = 0 ;
41102 PyObject * obj2 = 0 ;
41103 char * kwnames[] = {
41104 (char *) "self",(char *) "id",(char *) "helpString", NULL
41105 };
41106
41107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41109 if (!SWIG_IsOK(res1)) {
41110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41111 }
41112 arg1 = reinterpret_cast< wxMenu * >(argp1);
41113 ecode2 = SWIG_AsVal_int(obj1, &val2);
41114 if (!SWIG_IsOK(ecode2)) {
41115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41116 }
41117 arg2 = static_cast< int >(val2);
41118 {
41119 arg3 = wxString_in_helper(obj2);
41120 if (arg3 == NULL) SWIG_fail;
41121 temp3 = true;
41122 }
41123 {
41124 PyThreadState* __tstate = wxPyBeginAllowThreads();
41125 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41126 wxPyEndAllowThreads(__tstate);
41127 if (PyErr_Occurred()) SWIG_fail;
41128 }
41129 resultobj = SWIG_Py_Void();
41130 {
41131 if (temp3)
41132 delete arg3;
41133 }
41134 return resultobj;
41135 fail:
41136 {
41137 if (temp3)
41138 delete arg3;
41139 }
41140 return NULL;
41141 }
41142
41143
41144 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41145 PyObject *resultobj = 0;
41146 wxMenu *arg1 = (wxMenu *) 0 ;
41147 int arg2 ;
41148 wxString result;
41149 void *argp1 = 0 ;
41150 int res1 = 0 ;
41151 int val2 ;
41152 int ecode2 = 0 ;
41153 PyObject * obj0 = 0 ;
41154 PyObject * obj1 = 0 ;
41155 char * kwnames[] = {
41156 (char *) "self",(char *) "id", NULL
41157 };
41158
41159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41161 if (!SWIG_IsOK(res1)) {
41162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41163 }
41164 arg1 = reinterpret_cast< wxMenu * >(argp1);
41165 ecode2 = SWIG_AsVal_int(obj1, &val2);
41166 if (!SWIG_IsOK(ecode2)) {
41167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41168 }
41169 arg2 = static_cast< int >(val2);
41170 {
41171 PyThreadState* __tstate = wxPyBeginAllowThreads();
41172 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41173 wxPyEndAllowThreads(__tstate);
41174 if (PyErr_Occurred()) SWIG_fail;
41175 }
41176 {
41177 #if wxUSE_UNICODE
41178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41179 #else
41180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41181 #endif
41182 }
41183 return resultobj;
41184 fail:
41185 return NULL;
41186 }
41187
41188
41189 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41190 PyObject *resultobj = 0;
41191 wxMenu *arg1 = (wxMenu *) 0 ;
41192 wxString *arg2 = 0 ;
41193 void *argp1 = 0 ;
41194 int res1 = 0 ;
41195 bool temp2 = false ;
41196 PyObject * obj0 = 0 ;
41197 PyObject * obj1 = 0 ;
41198 char * kwnames[] = {
41199 (char *) "self",(char *) "title", NULL
41200 };
41201
41202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41204 if (!SWIG_IsOK(res1)) {
41205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41206 }
41207 arg1 = reinterpret_cast< wxMenu * >(argp1);
41208 {
41209 arg2 = wxString_in_helper(obj1);
41210 if (arg2 == NULL) SWIG_fail;
41211 temp2 = true;
41212 }
41213 {
41214 PyThreadState* __tstate = wxPyBeginAllowThreads();
41215 (arg1)->SetTitle((wxString const &)*arg2);
41216 wxPyEndAllowThreads(__tstate);
41217 if (PyErr_Occurred()) SWIG_fail;
41218 }
41219 resultobj = SWIG_Py_Void();
41220 {
41221 if (temp2)
41222 delete arg2;
41223 }
41224 return resultobj;
41225 fail:
41226 {
41227 if (temp2)
41228 delete arg2;
41229 }
41230 return NULL;
41231 }
41232
41233
41234 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41235 PyObject *resultobj = 0;
41236 wxMenu *arg1 = (wxMenu *) 0 ;
41237 wxString result;
41238 void *argp1 = 0 ;
41239 int res1 = 0 ;
41240 PyObject *swig_obj[1] ;
41241
41242 if (!args) SWIG_fail;
41243 swig_obj[0] = args;
41244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41245 if (!SWIG_IsOK(res1)) {
41246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41247 }
41248 arg1 = reinterpret_cast< wxMenu * >(argp1);
41249 {
41250 PyThreadState* __tstate = wxPyBeginAllowThreads();
41251 result = ((wxMenu const *)arg1)->GetTitle();
41252 wxPyEndAllowThreads(__tstate);
41253 if (PyErr_Occurred()) SWIG_fail;
41254 }
41255 {
41256 #if wxUSE_UNICODE
41257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41258 #else
41259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41260 #endif
41261 }
41262 return resultobj;
41263 fail:
41264 return NULL;
41265 }
41266
41267
41268 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41269 PyObject *resultobj = 0;
41270 wxMenu *arg1 = (wxMenu *) 0 ;
41271 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41272 void *argp1 = 0 ;
41273 int res1 = 0 ;
41274 void *argp2 = 0 ;
41275 int res2 = 0 ;
41276 PyObject * obj0 = 0 ;
41277 PyObject * obj1 = 0 ;
41278 char * kwnames[] = {
41279 (char *) "self",(char *) "handler", NULL
41280 };
41281
41282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41284 if (!SWIG_IsOK(res1)) {
41285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41286 }
41287 arg1 = reinterpret_cast< wxMenu * >(argp1);
41288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41289 if (!SWIG_IsOK(res2)) {
41290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41291 }
41292 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41293 {
41294 PyThreadState* __tstate = wxPyBeginAllowThreads();
41295 (arg1)->SetEventHandler(arg2);
41296 wxPyEndAllowThreads(__tstate);
41297 if (PyErr_Occurred()) SWIG_fail;
41298 }
41299 resultobj = SWIG_Py_Void();
41300 return resultobj;
41301 fail:
41302 return NULL;
41303 }
41304
41305
41306 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41307 PyObject *resultobj = 0;
41308 wxMenu *arg1 = (wxMenu *) 0 ;
41309 wxEvtHandler *result = 0 ;
41310 void *argp1 = 0 ;
41311 int res1 = 0 ;
41312 PyObject *swig_obj[1] ;
41313
41314 if (!args) SWIG_fail;
41315 swig_obj[0] = args;
41316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41317 if (!SWIG_IsOK(res1)) {
41318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41319 }
41320 arg1 = reinterpret_cast< wxMenu * >(argp1);
41321 {
41322 PyThreadState* __tstate = wxPyBeginAllowThreads();
41323 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41324 wxPyEndAllowThreads(__tstate);
41325 if (PyErr_Occurred()) SWIG_fail;
41326 }
41327 {
41328 resultobj = wxPyMake_wxObject(result, 0);
41329 }
41330 return resultobj;
41331 fail:
41332 return NULL;
41333 }
41334
41335
41336 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41337 PyObject *resultobj = 0;
41338 wxMenu *arg1 = (wxMenu *) 0 ;
41339 wxWindow *arg2 = (wxWindow *) 0 ;
41340 void *argp1 = 0 ;
41341 int res1 = 0 ;
41342 void *argp2 = 0 ;
41343 int res2 = 0 ;
41344 PyObject * obj0 = 0 ;
41345 PyObject * obj1 = 0 ;
41346 char * kwnames[] = {
41347 (char *) "self",(char *) "win", NULL
41348 };
41349
41350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41352 if (!SWIG_IsOK(res1)) {
41353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41354 }
41355 arg1 = reinterpret_cast< wxMenu * >(argp1);
41356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41357 if (!SWIG_IsOK(res2)) {
41358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41359 }
41360 arg2 = reinterpret_cast< wxWindow * >(argp2);
41361 {
41362 PyThreadState* __tstate = wxPyBeginAllowThreads();
41363 (arg1)->SetInvokingWindow(arg2);
41364 wxPyEndAllowThreads(__tstate);
41365 if (PyErr_Occurred()) SWIG_fail;
41366 }
41367 resultobj = SWIG_Py_Void();
41368 return resultobj;
41369 fail:
41370 return NULL;
41371 }
41372
41373
41374 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41375 PyObject *resultobj = 0;
41376 wxMenu *arg1 = (wxMenu *) 0 ;
41377 wxWindow *result = 0 ;
41378 void *argp1 = 0 ;
41379 int res1 = 0 ;
41380 PyObject *swig_obj[1] ;
41381
41382 if (!args) SWIG_fail;
41383 swig_obj[0] = args;
41384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41385 if (!SWIG_IsOK(res1)) {
41386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41387 }
41388 arg1 = reinterpret_cast< wxMenu * >(argp1);
41389 {
41390 PyThreadState* __tstate = wxPyBeginAllowThreads();
41391 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 {
41396 resultobj = wxPyMake_wxObject(result, 0);
41397 }
41398 return resultobj;
41399 fail:
41400 return NULL;
41401 }
41402
41403
41404 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41405 PyObject *resultobj = 0;
41406 wxMenu *arg1 = (wxMenu *) 0 ;
41407 long result;
41408 void *argp1 = 0 ;
41409 int res1 = 0 ;
41410 PyObject *swig_obj[1] ;
41411
41412 if (!args) SWIG_fail;
41413 swig_obj[0] = args;
41414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41415 if (!SWIG_IsOK(res1)) {
41416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41417 }
41418 arg1 = reinterpret_cast< wxMenu * >(argp1);
41419 {
41420 PyThreadState* __tstate = wxPyBeginAllowThreads();
41421 result = (long)((wxMenu const *)arg1)->GetStyle();
41422 wxPyEndAllowThreads(__tstate);
41423 if (PyErr_Occurred()) SWIG_fail;
41424 }
41425 resultobj = SWIG_From_long(static_cast< long >(result));
41426 return resultobj;
41427 fail:
41428 return NULL;
41429 }
41430
41431
41432 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41433 PyObject *resultobj = 0;
41434 wxMenu *arg1 = (wxMenu *) 0 ;
41435 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41436 void *argp1 = 0 ;
41437 int res1 = 0 ;
41438 void *argp2 = 0 ;
41439 int res2 = 0 ;
41440 PyObject * obj0 = 0 ;
41441 PyObject * obj1 = 0 ;
41442 char * kwnames[] = {
41443 (char *) "self",(char *) "source", NULL
41444 };
41445
41446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41448 if (!SWIG_IsOK(res1)) {
41449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41450 }
41451 arg1 = reinterpret_cast< wxMenu * >(argp1);
41452 if (obj1) {
41453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41454 if (!SWIG_IsOK(res2)) {
41455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41456 }
41457 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41458 }
41459 {
41460 PyThreadState* __tstate = wxPyBeginAllowThreads();
41461 (arg1)->UpdateUI(arg2);
41462 wxPyEndAllowThreads(__tstate);
41463 if (PyErr_Occurred()) SWIG_fail;
41464 }
41465 resultobj = SWIG_Py_Void();
41466 return resultobj;
41467 fail:
41468 return NULL;
41469 }
41470
41471
41472 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41473 PyObject *resultobj = 0;
41474 wxMenu *arg1 = (wxMenu *) 0 ;
41475 wxMenuBar *result = 0 ;
41476 void *argp1 = 0 ;
41477 int res1 = 0 ;
41478 PyObject *swig_obj[1] ;
41479
41480 if (!args) SWIG_fail;
41481 swig_obj[0] = args;
41482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41483 if (!SWIG_IsOK(res1)) {
41484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41485 }
41486 arg1 = reinterpret_cast< wxMenu * >(argp1);
41487 {
41488 PyThreadState* __tstate = wxPyBeginAllowThreads();
41489 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41490 wxPyEndAllowThreads(__tstate);
41491 if (PyErr_Occurred()) SWIG_fail;
41492 }
41493 {
41494 resultobj = wxPyMake_wxObject(result, (bool)0);
41495 }
41496 return resultobj;
41497 fail:
41498 return NULL;
41499 }
41500
41501
41502 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41503 PyObject *resultobj = 0;
41504 wxMenu *arg1 = (wxMenu *) 0 ;
41505 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41506 void *argp1 = 0 ;
41507 int res1 = 0 ;
41508 void *argp2 = 0 ;
41509 int res2 = 0 ;
41510 PyObject * obj0 = 0 ;
41511 PyObject * obj1 = 0 ;
41512 char * kwnames[] = {
41513 (char *) "self",(char *) "menubar", NULL
41514 };
41515
41516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41518 if (!SWIG_IsOK(res1)) {
41519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41520 }
41521 arg1 = reinterpret_cast< wxMenu * >(argp1);
41522 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41523 if (!SWIG_IsOK(res2)) {
41524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41525 }
41526 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41527 {
41528 PyThreadState* __tstate = wxPyBeginAllowThreads();
41529 (arg1)->Attach(arg2);
41530 wxPyEndAllowThreads(__tstate);
41531 if (PyErr_Occurred()) SWIG_fail;
41532 }
41533 resultobj = SWIG_Py_Void();
41534 return resultobj;
41535 fail:
41536 return NULL;
41537 }
41538
41539
41540 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41541 PyObject *resultobj = 0;
41542 wxMenu *arg1 = (wxMenu *) 0 ;
41543 void *argp1 = 0 ;
41544 int res1 = 0 ;
41545 PyObject *swig_obj[1] ;
41546
41547 if (!args) SWIG_fail;
41548 swig_obj[0] = args;
41549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41550 if (!SWIG_IsOK(res1)) {
41551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41552 }
41553 arg1 = reinterpret_cast< wxMenu * >(argp1);
41554 {
41555 PyThreadState* __tstate = wxPyBeginAllowThreads();
41556 (arg1)->Detach();
41557 wxPyEndAllowThreads(__tstate);
41558 if (PyErr_Occurred()) SWIG_fail;
41559 }
41560 resultobj = SWIG_Py_Void();
41561 return resultobj;
41562 fail:
41563 return NULL;
41564 }
41565
41566
41567 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41568 PyObject *resultobj = 0;
41569 wxMenu *arg1 = (wxMenu *) 0 ;
41570 bool result;
41571 void *argp1 = 0 ;
41572 int res1 = 0 ;
41573 PyObject *swig_obj[1] ;
41574
41575 if (!args) SWIG_fail;
41576 swig_obj[0] = args;
41577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41578 if (!SWIG_IsOK(res1)) {
41579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41580 }
41581 arg1 = reinterpret_cast< wxMenu * >(argp1);
41582 {
41583 PyThreadState* __tstate = wxPyBeginAllowThreads();
41584 result = (bool)((wxMenu const *)arg1)->IsAttached();
41585 wxPyEndAllowThreads(__tstate);
41586 if (PyErr_Occurred()) SWIG_fail;
41587 }
41588 {
41589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41590 }
41591 return resultobj;
41592 fail:
41593 return NULL;
41594 }
41595
41596
41597 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41598 PyObject *resultobj = 0;
41599 wxMenu *arg1 = (wxMenu *) 0 ;
41600 wxMenu *arg2 = (wxMenu *) 0 ;
41601 void *argp1 = 0 ;
41602 int res1 = 0 ;
41603 void *argp2 = 0 ;
41604 int res2 = 0 ;
41605 PyObject * obj0 = 0 ;
41606 PyObject * obj1 = 0 ;
41607 char * kwnames[] = {
41608 (char *) "self",(char *) "parent", NULL
41609 };
41610
41611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41613 if (!SWIG_IsOK(res1)) {
41614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41615 }
41616 arg1 = reinterpret_cast< wxMenu * >(argp1);
41617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41618 if (!SWIG_IsOK(res2)) {
41619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41620 }
41621 arg2 = reinterpret_cast< wxMenu * >(argp2);
41622 {
41623 PyThreadState* __tstate = wxPyBeginAllowThreads();
41624 (arg1)->SetParent(arg2);
41625 wxPyEndAllowThreads(__tstate);
41626 if (PyErr_Occurred()) SWIG_fail;
41627 }
41628 resultobj = SWIG_Py_Void();
41629 return resultobj;
41630 fail:
41631 return NULL;
41632 }
41633
41634
41635 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41636 PyObject *resultobj = 0;
41637 wxMenu *arg1 = (wxMenu *) 0 ;
41638 wxMenu *result = 0 ;
41639 void *argp1 = 0 ;
41640 int res1 = 0 ;
41641 PyObject *swig_obj[1] ;
41642
41643 if (!args) SWIG_fail;
41644 swig_obj[0] = args;
41645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41646 if (!SWIG_IsOK(res1)) {
41647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41648 }
41649 arg1 = reinterpret_cast< wxMenu * >(argp1);
41650 {
41651 PyThreadState* __tstate = wxPyBeginAllowThreads();
41652 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41653 wxPyEndAllowThreads(__tstate);
41654 if (PyErr_Occurred()) SWIG_fail;
41655 }
41656 {
41657 resultobj = wxPyMake_wxObject(result, 0);
41658 }
41659 return resultobj;
41660 fail:
41661 return NULL;
41662 }
41663
41664
41665 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41666 PyObject *obj;
41667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41668 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41669 return SWIG_Py_Void();
41670 }
41671
41672 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41673 return SWIG_Python_InitShadowInstance(args);
41674 }
41675
41676 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41677 PyObject *resultobj = 0;
41678 long arg1 = (long) 0 ;
41679 wxMenuBar *result = 0 ;
41680 long val1 ;
41681 int ecode1 = 0 ;
41682 PyObject * obj0 = 0 ;
41683 char * kwnames[] = {
41684 (char *) "style", NULL
41685 };
41686
41687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41688 if (obj0) {
41689 ecode1 = SWIG_AsVal_long(obj0, &val1);
41690 if (!SWIG_IsOK(ecode1)) {
41691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41692 }
41693 arg1 = static_cast< long >(val1);
41694 }
41695 {
41696 if (!wxPyCheckForApp()) SWIG_fail;
41697 PyThreadState* __tstate = wxPyBeginAllowThreads();
41698 result = (wxMenuBar *)new wxMenuBar(arg1);
41699 wxPyEndAllowThreads(__tstate);
41700 if (PyErr_Occurred()) SWIG_fail;
41701 }
41702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41703 return resultobj;
41704 fail:
41705 return NULL;
41706 }
41707
41708
41709 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41710 PyObject *resultobj = 0;
41711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41712 wxMenu *arg2 = (wxMenu *) 0 ;
41713 wxString *arg3 = 0 ;
41714 bool result;
41715 void *argp1 = 0 ;
41716 int res1 = 0 ;
41717 void *argp2 = 0 ;
41718 int res2 = 0 ;
41719 bool temp3 = false ;
41720 PyObject * obj0 = 0 ;
41721 PyObject * obj1 = 0 ;
41722 PyObject * obj2 = 0 ;
41723 char * kwnames[] = {
41724 (char *) "self",(char *) "menu",(char *) "title", NULL
41725 };
41726
41727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41729 if (!SWIG_IsOK(res1)) {
41730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41731 }
41732 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41734 if (!SWIG_IsOK(res2)) {
41735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41736 }
41737 arg2 = reinterpret_cast< wxMenu * >(argp2);
41738 {
41739 arg3 = wxString_in_helper(obj2);
41740 if (arg3 == NULL) SWIG_fail;
41741 temp3 = true;
41742 }
41743 {
41744 PyThreadState* __tstate = wxPyBeginAllowThreads();
41745 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41746 wxPyEndAllowThreads(__tstate);
41747 if (PyErr_Occurred()) SWIG_fail;
41748 }
41749 {
41750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41751 }
41752 {
41753 if (temp3)
41754 delete arg3;
41755 }
41756 return resultobj;
41757 fail:
41758 {
41759 if (temp3)
41760 delete arg3;
41761 }
41762 return NULL;
41763 }
41764
41765
41766 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41767 PyObject *resultobj = 0;
41768 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41769 size_t arg2 ;
41770 wxMenu *arg3 = (wxMenu *) 0 ;
41771 wxString *arg4 = 0 ;
41772 bool result;
41773 void *argp1 = 0 ;
41774 int res1 = 0 ;
41775 size_t val2 ;
41776 int ecode2 = 0 ;
41777 void *argp3 = 0 ;
41778 int res3 = 0 ;
41779 bool temp4 = false ;
41780 PyObject * obj0 = 0 ;
41781 PyObject * obj1 = 0 ;
41782 PyObject * obj2 = 0 ;
41783 PyObject * obj3 = 0 ;
41784 char * kwnames[] = {
41785 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41786 };
41787
41788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41792 }
41793 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41794 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41795 if (!SWIG_IsOK(ecode2)) {
41796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41797 }
41798 arg2 = static_cast< size_t >(val2);
41799 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41800 if (!SWIG_IsOK(res3)) {
41801 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41802 }
41803 arg3 = reinterpret_cast< wxMenu * >(argp3);
41804 {
41805 arg4 = wxString_in_helper(obj3);
41806 if (arg4 == NULL) SWIG_fail;
41807 temp4 = true;
41808 }
41809 {
41810 PyThreadState* __tstate = wxPyBeginAllowThreads();
41811 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41812 wxPyEndAllowThreads(__tstate);
41813 if (PyErr_Occurred()) SWIG_fail;
41814 }
41815 {
41816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41817 }
41818 {
41819 if (temp4)
41820 delete arg4;
41821 }
41822 return resultobj;
41823 fail:
41824 {
41825 if (temp4)
41826 delete arg4;
41827 }
41828 return NULL;
41829 }
41830
41831
41832 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41833 PyObject *resultobj = 0;
41834 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41835 size_t result;
41836 void *argp1 = 0 ;
41837 int res1 = 0 ;
41838 PyObject *swig_obj[1] ;
41839
41840 if (!args) SWIG_fail;
41841 swig_obj[0] = args;
41842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41843 if (!SWIG_IsOK(res1)) {
41844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41845 }
41846 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41847 {
41848 PyThreadState* __tstate = wxPyBeginAllowThreads();
41849 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41854 return resultobj;
41855 fail:
41856 return NULL;
41857 }
41858
41859
41860 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41861 PyObject *resultobj = 0;
41862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41863 size_t arg2 ;
41864 wxMenu *result = 0 ;
41865 void *argp1 = 0 ;
41866 int res1 = 0 ;
41867 size_t val2 ;
41868 int ecode2 = 0 ;
41869 PyObject * obj0 = 0 ;
41870 PyObject * obj1 = 0 ;
41871 char * kwnames[] = {
41872 (char *) "self",(char *) "pos", NULL
41873 };
41874
41875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41877 if (!SWIG_IsOK(res1)) {
41878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41879 }
41880 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41881 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41882 if (!SWIG_IsOK(ecode2)) {
41883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41884 }
41885 arg2 = static_cast< size_t >(val2);
41886 {
41887 PyThreadState* __tstate = wxPyBeginAllowThreads();
41888 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41889 wxPyEndAllowThreads(__tstate);
41890 if (PyErr_Occurred()) SWIG_fail;
41891 }
41892 {
41893 resultobj = wxPyMake_wxObject(result, 0);
41894 }
41895 return resultobj;
41896 fail:
41897 return NULL;
41898 }
41899
41900
41901 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41902 PyObject *resultobj = 0;
41903 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41904 size_t arg2 ;
41905 wxMenu *arg3 = (wxMenu *) 0 ;
41906 wxString *arg4 = 0 ;
41907 wxMenu *result = 0 ;
41908 void *argp1 = 0 ;
41909 int res1 = 0 ;
41910 size_t val2 ;
41911 int ecode2 = 0 ;
41912 void *argp3 = 0 ;
41913 int res3 = 0 ;
41914 bool temp4 = false ;
41915 PyObject * obj0 = 0 ;
41916 PyObject * obj1 = 0 ;
41917 PyObject * obj2 = 0 ;
41918 PyObject * obj3 = 0 ;
41919 char * kwnames[] = {
41920 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41921 };
41922
41923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41925 if (!SWIG_IsOK(res1)) {
41926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41927 }
41928 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41929 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41930 if (!SWIG_IsOK(ecode2)) {
41931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41932 }
41933 arg2 = static_cast< size_t >(val2);
41934 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41935 if (!SWIG_IsOK(res3)) {
41936 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41937 }
41938 arg3 = reinterpret_cast< wxMenu * >(argp3);
41939 {
41940 arg4 = wxString_in_helper(obj3);
41941 if (arg4 == NULL) SWIG_fail;
41942 temp4 = true;
41943 }
41944 {
41945 PyThreadState* __tstate = wxPyBeginAllowThreads();
41946 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41947 wxPyEndAllowThreads(__tstate);
41948 if (PyErr_Occurred()) SWIG_fail;
41949 }
41950 {
41951 resultobj = wxPyMake_wxObject(result, 0);
41952 }
41953 {
41954 if (temp4)
41955 delete arg4;
41956 }
41957 return resultobj;
41958 fail:
41959 {
41960 if (temp4)
41961 delete arg4;
41962 }
41963 return NULL;
41964 }
41965
41966
41967 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41968 PyObject *resultobj = 0;
41969 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41970 size_t arg2 ;
41971 wxMenu *result = 0 ;
41972 void *argp1 = 0 ;
41973 int res1 = 0 ;
41974 size_t val2 ;
41975 int ecode2 = 0 ;
41976 PyObject * obj0 = 0 ;
41977 PyObject * obj1 = 0 ;
41978 char * kwnames[] = {
41979 (char *) "self",(char *) "pos", NULL
41980 };
41981
41982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41984 if (!SWIG_IsOK(res1)) {
41985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41986 }
41987 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41988 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41989 if (!SWIG_IsOK(ecode2)) {
41990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41991 }
41992 arg2 = static_cast< size_t >(val2);
41993 {
41994 PyThreadState* __tstate = wxPyBeginAllowThreads();
41995 result = (wxMenu *)(arg1)->Remove(arg2);
41996 wxPyEndAllowThreads(__tstate);
41997 if (PyErr_Occurred()) SWIG_fail;
41998 }
41999 {
42000 resultobj = wxPyMake_wxObject(result, 0);
42001 }
42002 return resultobj;
42003 fail:
42004 return NULL;
42005 }
42006
42007
42008 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42009 PyObject *resultobj = 0;
42010 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42011 size_t arg2 ;
42012 bool arg3 ;
42013 void *argp1 = 0 ;
42014 int res1 = 0 ;
42015 size_t val2 ;
42016 int ecode2 = 0 ;
42017 bool val3 ;
42018 int ecode3 = 0 ;
42019 PyObject * obj0 = 0 ;
42020 PyObject * obj1 = 0 ;
42021 PyObject * obj2 = 0 ;
42022 char * kwnames[] = {
42023 (char *) "self",(char *) "pos",(char *) "enable", NULL
42024 };
42025
42026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42028 if (!SWIG_IsOK(res1)) {
42029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42030 }
42031 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42032 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42033 if (!SWIG_IsOK(ecode2)) {
42034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42035 }
42036 arg2 = static_cast< size_t >(val2);
42037 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42038 if (!SWIG_IsOK(ecode3)) {
42039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42040 }
42041 arg3 = static_cast< bool >(val3);
42042 {
42043 PyThreadState* __tstate = wxPyBeginAllowThreads();
42044 (arg1)->EnableTop(arg2,arg3);
42045 wxPyEndAllowThreads(__tstate);
42046 if (PyErr_Occurred()) SWIG_fail;
42047 }
42048 resultobj = SWIG_Py_Void();
42049 return resultobj;
42050 fail:
42051 return NULL;
42052 }
42053
42054
42055 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42056 PyObject *resultobj = 0;
42057 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42058 size_t arg2 ;
42059 bool result;
42060 void *argp1 = 0 ;
42061 int res1 = 0 ;
42062 size_t val2 ;
42063 int ecode2 = 0 ;
42064 PyObject * obj0 = 0 ;
42065 PyObject * obj1 = 0 ;
42066 char * kwnames[] = {
42067 (char *) "self",(char *) "pos", NULL
42068 };
42069
42070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42072 if (!SWIG_IsOK(res1)) {
42073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42074 }
42075 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42076 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42077 if (!SWIG_IsOK(ecode2)) {
42078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42079 }
42080 arg2 = static_cast< size_t >(val2);
42081 {
42082 PyThreadState* __tstate = wxPyBeginAllowThreads();
42083 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42084 wxPyEndAllowThreads(__tstate);
42085 if (PyErr_Occurred()) SWIG_fail;
42086 }
42087 {
42088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42089 }
42090 return resultobj;
42091 fail:
42092 return NULL;
42093 }
42094
42095
42096 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj = 0;
42098 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42099 size_t arg2 ;
42100 wxString *arg3 = 0 ;
42101 void *argp1 = 0 ;
42102 int res1 = 0 ;
42103 size_t val2 ;
42104 int ecode2 = 0 ;
42105 bool temp3 = false ;
42106 PyObject * obj0 = 0 ;
42107 PyObject * obj1 = 0 ;
42108 PyObject * obj2 = 0 ;
42109 char * kwnames[] = {
42110 (char *) "self",(char *) "pos",(char *) "label", NULL
42111 };
42112
42113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42115 if (!SWIG_IsOK(res1)) {
42116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42117 }
42118 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42119 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42120 if (!SWIG_IsOK(ecode2)) {
42121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42122 }
42123 arg2 = static_cast< size_t >(val2);
42124 {
42125 arg3 = wxString_in_helper(obj2);
42126 if (arg3 == NULL) SWIG_fail;
42127 temp3 = true;
42128 }
42129 {
42130 PyThreadState* __tstate = wxPyBeginAllowThreads();
42131 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42132 wxPyEndAllowThreads(__tstate);
42133 if (PyErr_Occurred()) SWIG_fail;
42134 }
42135 resultobj = SWIG_Py_Void();
42136 {
42137 if (temp3)
42138 delete arg3;
42139 }
42140 return resultobj;
42141 fail:
42142 {
42143 if (temp3)
42144 delete arg3;
42145 }
42146 return NULL;
42147 }
42148
42149
42150 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42151 PyObject *resultobj = 0;
42152 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42153 size_t arg2 ;
42154 wxString result;
42155 void *argp1 = 0 ;
42156 int res1 = 0 ;
42157 size_t val2 ;
42158 int ecode2 = 0 ;
42159 PyObject * obj0 = 0 ;
42160 PyObject * obj1 = 0 ;
42161 char * kwnames[] = {
42162 (char *) "self",(char *) "pos", NULL
42163 };
42164
42165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42167 if (!SWIG_IsOK(res1)) {
42168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42169 }
42170 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42171 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42172 if (!SWIG_IsOK(ecode2)) {
42173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42174 }
42175 arg2 = static_cast< size_t >(val2);
42176 {
42177 PyThreadState* __tstate = wxPyBeginAllowThreads();
42178 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42179 wxPyEndAllowThreads(__tstate);
42180 if (PyErr_Occurred()) SWIG_fail;
42181 }
42182 {
42183 #if wxUSE_UNICODE
42184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42185 #else
42186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42187 #endif
42188 }
42189 return resultobj;
42190 fail:
42191 return NULL;
42192 }
42193
42194
42195 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42196 PyObject *resultobj = 0;
42197 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42198 wxString *arg2 = 0 ;
42199 wxString *arg3 = 0 ;
42200 int result;
42201 void *argp1 = 0 ;
42202 int res1 = 0 ;
42203 bool temp2 = false ;
42204 bool temp3 = false ;
42205 PyObject * obj0 = 0 ;
42206 PyObject * obj1 = 0 ;
42207 PyObject * obj2 = 0 ;
42208 char * kwnames[] = {
42209 (char *) "self",(char *) "menu",(char *) "item", NULL
42210 };
42211
42212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42214 if (!SWIG_IsOK(res1)) {
42215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42216 }
42217 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42218 {
42219 arg2 = wxString_in_helper(obj1);
42220 if (arg2 == NULL) SWIG_fail;
42221 temp2 = true;
42222 }
42223 {
42224 arg3 = wxString_in_helper(obj2);
42225 if (arg3 == NULL) SWIG_fail;
42226 temp3 = true;
42227 }
42228 {
42229 PyThreadState* __tstate = wxPyBeginAllowThreads();
42230 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42231 wxPyEndAllowThreads(__tstate);
42232 if (PyErr_Occurred()) SWIG_fail;
42233 }
42234 resultobj = SWIG_From_int(static_cast< int >(result));
42235 {
42236 if (temp2)
42237 delete arg2;
42238 }
42239 {
42240 if (temp3)
42241 delete arg3;
42242 }
42243 return resultobj;
42244 fail:
42245 {
42246 if (temp2)
42247 delete arg2;
42248 }
42249 {
42250 if (temp3)
42251 delete arg3;
42252 }
42253 return NULL;
42254 }
42255
42256
42257 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42258 PyObject *resultobj = 0;
42259 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42260 int arg2 ;
42261 wxMenuItem *result = 0 ;
42262 void *argp1 = 0 ;
42263 int res1 = 0 ;
42264 int val2 ;
42265 int ecode2 = 0 ;
42266 PyObject * obj0 = 0 ;
42267 PyObject * obj1 = 0 ;
42268 char * kwnames[] = {
42269 (char *) "self",(char *) "id", NULL
42270 };
42271
42272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42274 if (!SWIG_IsOK(res1)) {
42275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42276 }
42277 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42278 ecode2 = SWIG_AsVal_int(obj1, &val2);
42279 if (!SWIG_IsOK(ecode2)) {
42280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42281 }
42282 arg2 = static_cast< int >(val2);
42283 {
42284 PyThreadState* __tstate = wxPyBeginAllowThreads();
42285 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42286 wxPyEndAllowThreads(__tstate);
42287 if (PyErr_Occurred()) SWIG_fail;
42288 }
42289 {
42290 resultobj = wxPyMake_wxObject(result, (bool)0);
42291 }
42292 return resultobj;
42293 fail:
42294 return NULL;
42295 }
42296
42297
42298 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42299 PyObject *resultobj = 0;
42300 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42301 wxString *arg2 = 0 ;
42302 int result;
42303 void *argp1 = 0 ;
42304 int res1 = 0 ;
42305 bool temp2 = false ;
42306 PyObject * obj0 = 0 ;
42307 PyObject * obj1 = 0 ;
42308 char * kwnames[] = {
42309 (char *) "self",(char *) "title", NULL
42310 };
42311
42312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42314 if (!SWIG_IsOK(res1)) {
42315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42316 }
42317 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42318 {
42319 arg2 = wxString_in_helper(obj1);
42320 if (arg2 == NULL) SWIG_fail;
42321 temp2 = true;
42322 }
42323 {
42324 PyThreadState* __tstate = wxPyBeginAllowThreads();
42325 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42326 wxPyEndAllowThreads(__tstate);
42327 if (PyErr_Occurred()) SWIG_fail;
42328 }
42329 resultobj = SWIG_From_int(static_cast< int >(result));
42330 {
42331 if (temp2)
42332 delete arg2;
42333 }
42334 return resultobj;
42335 fail:
42336 {
42337 if (temp2)
42338 delete arg2;
42339 }
42340 return NULL;
42341 }
42342
42343
42344 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42345 PyObject *resultobj = 0;
42346 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42347 int arg2 ;
42348 bool arg3 ;
42349 void *argp1 = 0 ;
42350 int res1 = 0 ;
42351 int val2 ;
42352 int ecode2 = 0 ;
42353 bool val3 ;
42354 int ecode3 = 0 ;
42355 PyObject * obj0 = 0 ;
42356 PyObject * obj1 = 0 ;
42357 PyObject * obj2 = 0 ;
42358 char * kwnames[] = {
42359 (char *) "self",(char *) "id",(char *) "enable", NULL
42360 };
42361
42362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42364 if (!SWIG_IsOK(res1)) {
42365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42366 }
42367 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42368 ecode2 = SWIG_AsVal_int(obj1, &val2);
42369 if (!SWIG_IsOK(ecode2)) {
42370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42371 }
42372 arg2 = static_cast< int >(val2);
42373 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42374 if (!SWIG_IsOK(ecode3)) {
42375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42376 }
42377 arg3 = static_cast< bool >(val3);
42378 {
42379 PyThreadState* __tstate = wxPyBeginAllowThreads();
42380 (arg1)->Enable(arg2,arg3);
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 resultobj = SWIG_Py_Void();
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj = 0;
42393 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42394 int arg2 ;
42395 bool arg3 ;
42396 void *argp1 = 0 ;
42397 int res1 = 0 ;
42398 int val2 ;
42399 int ecode2 = 0 ;
42400 bool val3 ;
42401 int ecode3 = 0 ;
42402 PyObject * obj0 = 0 ;
42403 PyObject * obj1 = 0 ;
42404 PyObject * obj2 = 0 ;
42405 char * kwnames[] = {
42406 (char *) "self",(char *) "id",(char *) "check", NULL
42407 };
42408
42409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42411 if (!SWIG_IsOK(res1)) {
42412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42413 }
42414 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42415 ecode2 = SWIG_AsVal_int(obj1, &val2);
42416 if (!SWIG_IsOK(ecode2)) {
42417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42418 }
42419 arg2 = static_cast< int >(val2);
42420 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42421 if (!SWIG_IsOK(ecode3)) {
42422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42423 }
42424 arg3 = static_cast< bool >(val3);
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 (arg1)->Check(arg2,arg3);
42428 wxPyEndAllowThreads(__tstate);
42429 if (PyErr_Occurred()) SWIG_fail;
42430 }
42431 resultobj = SWIG_Py_Void();
42432 return resultobj;
42433 fail:
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42439 PyObject *resultobj = 0;
42440 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42441 int arg2 ;
42442 bool result;
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:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42455 if (!SWIG_IsOK(res1)) {
42456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42457 }
42458 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42459 ecode2 = SWIG_AsVal_int(obj1, &val2);
42460 if (!SWIG_IsOK(ecode2)) {
42461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42462 }
42463 arg2 = static_cast< int >(val2);
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42467 wxPyEndAllowThreads(__tstate);
42468 if (PyErr_Occurred()) SWIG_fail;
42469 }
42470 {
42471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42472 }
42473 return resultobj;
42474 fail:
42475 return NULL;
42476 }
42477
42478
42479 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42480 PyObject *resultobj = 0;
42481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42482 int arg2 ;
42483 bool result;
42484 void *argp1 = 0 ;
42485 int res1 = 0 ;
42486 int val2 ;
42487 int ecode2 = 0 ;
42488 PyObject * obj0 = 0 ;
42489 PyObject * obj1 = 0 ;
42490 char * kwnames[] = {
42491 (char *) "self",(char *) "id", NULL
42492 };
42493
42494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42496 if (!SWIG_IsOK(res1)) {
42497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42498 }
42499 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42500 ecode2 = SWIG_AsVal_int(obj1, &val2);
42501 if (!SWIG_IsOK(ecode2)) {
42502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42503 }
42504 arg2 = static_cast< int >(val2);
42505 {
42506 PyThreadState* __tstate = wxPyBeginAllowThreads();
42507 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42508 wxPyEndAllowThreads(__tstate);
42509 if (PyErr_Occurred()) SWIG_fail;
42510 }
42511 {
42512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42513 }
42514 return resultobj;
42515 fail:
42516 return NULL;
42517 }
42518
42519
42520 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42521 PyObject *resultobj = 0;
42522 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42523 int arg2 ;
42524 wxString *arg3 = 0 ;
42525 void *argp1 = 0 ;
42526 int res1 = 0 ;
42527 int val2 ;
42528 int ecode2 = 0 ;
42529 bool temp3 = false ;
42530 PyObject * obj0 = 0 ;
42531 PyObject * obj1 = 0 ;
42532 PyObject * obj2 = 0 ;
42533 char * kwnames[] = {
42534 (char *) "self",(char *) "id",(char *) "label", NULL
42535 };
42536
42537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42539 if (!SWIG_IsOK(res1)) {
42540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42541 }
42542 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42543 ecode2 = SWIG_AsVal_int(obj1, &val2);
42544 if (!SWIG_IsOK(ecode2)) {
42545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42546 }
42547 arg2 = static_cast< int >(val2);
42548 {
42549 arg3 = wxString_in_helper(obj2);
42550 if (arg3 == NULL) SWIG_fail;
42551 temp3 = true;
42552 }
42553 {
42554 PyThreadState* __tstate = wxPyBeginAllowThreads();
42555 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42556 wxPyEndAllowThreads(__tstate);
42557 if (PyErr_Occurred()) SWIG_fail;
42558 }
42559 resultobj = SWIG_Py_Void();
42560 {
42561 if (temp3)
42562 delete arg3;
42563 }
42564 return resultobj;
42565 fail:
42566 {
42567 if (temp3)
42568 delete arg3;
42569 }
42570 return NULL;
42571 }
42572
42573
42574 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42575 PyObject *resultobj = 0;
42576 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42577 int arg2 ;
42578 wxString result;
42579 void *argp1 = 0 ;
42580 int res1 = 0 ;
42581 int val2 ;
42582 int ecode2 = 0 ;
42583 PyObject * obj0 = 0 ;
42584 PyObject * obj1 = 0 ;
42585 char * kwnames[] = {
42586 (char *) "self",(char *) "id", NULL
42587 };
42588
42589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42591 if (!SWIG_IsOK(res1)) {
42592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42593 }
42594 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42595 ecode2 = SWIG_AsVal_int(obj1, &val2);
42596 if (!SWIG_IsOK(ecode2)) {
42597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42598 }
42599 arg2 = static_cast< int >(val2);
42600 {
42601 PyThreadState* __tstate = wxPyBeginAllowThreads();
42602 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42603 wxPyEndAllowThreads(__tstate);
42604 if (PyErr_Occurred()) SWIG_fail;
42605 }
42606 {
42607 #if wxUSE_UNICODE
42608 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42609 #else
42610 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42611 #endif
42612 }
42613 return resultobj;
42614 fail:
42615 return NULL;
42616 }
42617
42618
42619 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42620 PyObject *resultobj = 0;
42621 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42622 int arg2 ;
42623 wxString *arg3 = 0 ;
42624 void *argp1 = 0 ;
42625 int res1 = 0 ;
42626 int val2 ;
42627 int ecode2 = 0 ;
42628 bool temp3 = false ;
42629 PyObject * obj0 = 0 ;
42630 PyObject * obj1 = 0 ;
42631 PyObject * obj2 = 0 ;
42632 char * kwnames[] = {
42633 (char *) "self",(char *) "id",(char *) "helpString", NULL
42634 };
42635
42636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42638 if (!SWIG_IsOK(res1)) {
42639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42640 }
42641 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42642 ecode2 = SWIG_AsVal_int(obj1, &val2);
42643 if (!SWIG_IsOK(ecode2)) {
42644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42645 }
42646 arg2 = static_cast< int >(val2);
42647 {
42648 arg3 = wxString_in_helper(obj2);
42649 if (arg3 == NULL) SWIG_fail;
42650 temp3 = true;
42651 }
42652 {
42653 PyThreadState* __tstate = wxPyBeginAllowThreads();
42654 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42655 wxPyEndAllowThreads(__tstate);
42656 if (PyErr_Occurred()) SWIG_fail;
42657 }
42658 resultobj = SWIG_Py_Void();
42659 {
42660 if (temp3)
42661 delete arg3;
42662 }
42663 return resultobj;
42664 fail:
42665 {
42666 if (temp3)
42667 delete arg3;
42668 }
42669 return NULL;
42670 }
42671
42672
42673 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42674 PyObject *resultobj = 0;
42675 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42676 int arg2 ;
42677 wxString result;
42678 void *argp1 = 0 ;
42679 int res1 = 0 ;
42680 int val2 ;
42681 int ecode2 = 0 ;
42682 PyObject * obj0 = 0 ;
42683 PyObject * obj1 = 0 ;
42684 char * kwnames[] = {
42685 (char *) "self",(char *) "id", NULL
42686 };
42687
42688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42690 if (!SWIG_IsOK(res1)) {
42691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42692 }
42693 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42694 ecode2 = SWIG_AsVal_int(obj1, &val2);
42695 if (!SWIG_IsOK(ecode2)) {
42696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42697 }
42698 arg2 = static_cast< int >(val2);
42699 {
42700 PyThreadState* __tstate = wxPyBeginAllowThreads();
42701 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42702 wxPyEndAllowThreads(__tstate);
42703 if (PyErr_Occurred()) SWIG_fail;
42704 }
42705 {
42706 #if wxUSE_UNICODE
42707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42708 #else
42709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42710 #endif
42711 }
42712 return resultobj;
42713 fail:
42714 return NULL;
42715 }
42716
42717
42718 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42719 PyObject *resultobj = 0;
42720 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42721 wxFrame *result = 0 ;
42722 void *argp1 = 0 ;
42723 int res1 = 0 ;
42724 PyObject *swig_obj[1] ;
42725
42726 if (!args) SWIG_fail;
42727 swig_obj[0] = args;
42728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42729 if (!SWIG_IsOK(res1)) {
42730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42731 }
42732 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42733 {
42734 PyThreadState* __tstate = wxPyBeginAllowThreads();
42735 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42736 wxPyEndAllowThreads(__tstate);
42737 if (PyErr_Occurred()) SWIG_fail;
42738 }
42739 {
42740 resultobj = wxPyMake_wxObject(result, (bool)0);
42741 }
42742 return resultobj;
42743 fail:
42744 return NULL;
42745 }
42746
42747
42748 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42749 PyObject *resultobj = 0;
42750 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42751 bool result;
42752 void *argp1 = 0 ;
42753 int res1 = 0 ;
42754 PyObject *swig_obj[1] ;
42755
42756 if (!args) SWIG_fail;
42757 swig_obj[0] = args;
42758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42759 if (!SWIG_IsOK(res1)) {
42760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42761 }
42762 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42763 {
42764 PyThreadState* __tstate = wxPyBeginAllowThreads();
42765 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42766 wxPyEndAllowThreads(__tstate);
42767 if (PyErr_Occurred()) SWIG_fail;
42768 }
42769 {
42770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42771 }
42772 return resultobj;
42773 fail:
42774 return NULL;
42775 }
42776
42777
42778 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42779 PyObject *resultobj = 0;
42780 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42781 wxFrame *arg2 = (wxFrame *) 0 ;
42782 void *argp1 = 0 ;
42783 int res1 = 0 ;
42784 void *argp2 = 0 ;
42785 int res2 = 0 ;
42786 PyObject * obj0 = 0 ;
42787 PyObject * obj1 = 0 ;
42788 char * kwnames[] = {
42789 (char *) "self",(char *) "frame", NULL
42790 };
42791
42792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42794 if (!SWIG_IsOK(res1)) {
42795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42796 }
42797 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42799 if (!SWIG_IsOK(res2)) {
42800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42801 }
42802 arg2 = reinterpret_cast< wxFrame * >(argp2);
42803 {
42804 PyThreadState* __tstate = wxPyBeginAllowThreads();
42805 (arg1)->Attach(arg2);
42806 wxPyEndAllowThreads(__tstate);
42807 if (PyErr_Occurred()) SWIG_fail;
42808 }
42809 resultobj = SWIG_Py_Void();
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42817 PyObject *resultobj = 0;
42818 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42819 void *argp1 = 0 ;
42820 int res1 = 0 ;
42821 PyObject *swig_obj[1] ;
42822
42823 if (!args) SWIG_fail;
42824 swig_obj[0] = args;
42825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42826 if (!SWIG_IsOK(res1)) {
42827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42828 }
42829 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42830 {
42831 PyThreadState* __tstate = wxPyBeginAllowThreads();
42832 (arg1)->Detach();
42833 wxPyEndAllowThreads(__tstate);
42834 if (PyErr_Occurred()) SWIG_fail;
42835 }
42836 resultobj = SWIG_Py_Void();
42837 return resultobj;
42838 fail:
42839 return NULL;
42840 }
42841
42842
42843 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42844 PyObject *resultobj = 0;
42845 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42846 void *argp1 = 0 ;
42847 int res1 = 0 ;
42848 PyObject *swig_obj[1] ;
42849
42850 if (!args) SWIG_fail;
42851 swig_obj[0] = args;
42852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42853 if (!SWIG_IsOK(res1)) {
42854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42855 }
42856 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42857 {
42858 PyThreadState* __tstate = wxPyBeginAllowThreads();
42859 (arg1)->UpdateMenus();
42860 wxPyEndAllowThreads(__tstate);
42861 if (PyErr_Occurred()) SWIG_fail;
42862 }
42863 resultobj = SWIG_Py_Void();
42864 return resultobj;
42865 fail:
42866 return NULL;
42867 }
42868
42869
42870 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42871 PyObject *resultobj = 0;
42872 bool arg1 ;
42873 bool val1 ;
42874 int ecode1 = 0 ;
42875 PyObject * obj0 = 0 ;
42876 char * kwnames[] = {
42877 (char *) "enable", NULL
42878 };
42879
42880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42881 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42882 if (!SWIG_IsOK(ecode1)) {
42883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42884 }
42885 arg1 = static_cast< bool >(val1);
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 wxMenuBar_SetAutoWindowMenu(arg1);
42889 wxPyEndAllowThreads(__tstate);
42890 if (PyErr_Occurred()) SWIG_fail;
42891 }
42892 resultobj = SWIG_Py_Void();
42893 return resultobj;
42894 fail:
42895 return NULL;
42896 }
42897
42898
42899 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42900 PyObject *resultobj = 0;
42901 bool result;
42902
42903 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42904 {
42905 PyThreadState* __tstate = wxPyBeginAllowThreads();
42906 result = (bool)wxMenuBar_GetAutoWindowMenu();
42907 wxPyEndAllowThreads(__tstate);
42908 if (PyErr_Occurred()) SWIG_fail;
42909 }
42910 {
42911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42912 }
42913 return resultobj;
42914 fail:
42915 return NULL;
42916 }
42917
42918
42919 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42920 PyObject *obj;
42921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42922 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42923 return SWIG_Py_Void();
42924 }
42925
42926 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42927 return SWIG_Python_InitShadowInstance(args);
42928 }
42929
42930 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42931 PyObject *resultobj = 0;
42932 wxMenu *arg1 = (wxMenu *) NULL ;
42933 int arg2 = (int) wxID_ANY ;
42934 wxString const &arg3_defvalue = wxPyEmptyString ;
42935 wxString *arg3 = (wxString *) &arg3_defvalue ;
42936 wxString const &arg4_defvalue = wxPyEmptyString ;
42937 wxString *arg4 = (wxString *) &arg4_defvalue ;
42938 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42939 wxMenu *arg6 = (wxMenu *) NULL ;
42940 wxMenuItem *result = 0 ;
42941 void *argp1 = 0 ;
42942 int res1 = 0 ;
42943 int val2 ;
42944 int ecode2 = 0 ;
42945 bool temp3 = false ;
42946 bool temp4 = false ;
42947 int val5 ;
42948 int ecode5 = 0 ;
42949 void *argp6 = 0 ;
42950 int res6 = 0 ;
42951 PyObject * obj0 = 0 ;
42952 PyObject * obj1 = 0 ;
42953 PyObject * obj2 = 0 ;
42954 PyObject * obj3 = 0 ;
42955 PyObject * obj4 = 0 ;
42956 PyObject * obj5 = 0 ;
42957 char * kwnames[] = {
42958 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42959 };
42960
42961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42962 if (obj0) {
42963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42964 if (!SWIG_IsOK(res1)) {
42965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42966 }
42967 arg1 = reinterpret_cast< wxMenu * >(argp1);
42968 }
42969 if (obj1) {
42970 ecode2 = SWIG_AsVal_int(obj1, &val2);
42971 if (!SWIG_IsOK(ecode2)) {
42972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42973 }
42974 arg2 = static_cast< int >(val2);
42975 }
42976 if (obj2) {
42977 {
42978 arg3 = wxString_in_helper(obj2);
42979 if (arg3 == NULL) SWIG_fail;
42980 temp3 = true;
42981 }
42982 }
42983 if (obj3) {
42984 {
42985 arg4 = wxString_in_helper(obj3);
42986 if (arg4 == NULL) SWIG_fail;
42987 temp4 = true;
42988 }
42989 }
42990 if (obj4) {
42991 ecode5 = SWIG_AsVal_int(obj4, &val5);
42992 if (!SWIG_IsOK(ecode5)) {
42993 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42994 }
42995 arg5 = static_cast< wxItemKind >(val5);
42996 }
42997 if (obj5) {
42998 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42999 if (!SWIG_IsOK(res6)) {
43000 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43001 }
43002 arg6 = reinterpret_cast< wxMenu * >(argp6);
43003 }
43004 {
43005 PyThreadState* __tstate = wxPyBeginAllowThreads();
43006 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43007 wxPyEndAllowThreads(__tstate);
43008 if (PyErr_Occurred()) SWIG_fail;
43009 }
43010 {
43011 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43012 }
43013 {
43014 if (temp3)
43015 delete arg3;
43016 }
43017 {
43018 if (temp4)
43019 delete arg4;
43020 }
43021 return resultobj;
43022 fail:
43023 {
43024 if (temp3)
43025 delete arg3;
43026 }
43027 {
43028 if (temp4)
43029 delete arg4;
43030 }
43031 return NULL;
43032 }
43033
43034
43035 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43036 PyObject *resultobj = 0;
43037 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43038 void *argp1 = 0 ;
43039 int res1 = 0 ;
43040 PyObject *swig_obj[1] ;
43041
43042 if (!args) SWIG_fail;
43043 swig_obj[0] = args;
43044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43045 if (!SWIG_IsOK(res1)) {
43046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43047 }
43048 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43049 {
43050 PyThreadState* __tstate = wxPyBeginAllowThreads();
43051 delete arg1;
43052
43053 wxPyEndAllowThreads(__tstate);
43054 if (PyErr_Occurred()) SWIG_fail;
43055 }
43056 resultobj = SWIG_Py_Void();
43057 return resultobj;
43058 fail:
43059 return NULL;
43060 }
43061
43062
43063 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43064 PyObject *resultobj = 0;
43065 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43066 wxMenu *result = 0 ;
43067 void *argp1 = 0 ;
43068 int res1 = 0 ;
43069 PyObject *swig_obj[1] ;
43070
43071 if (!args) SWIG_fail;
43072 swig_obj[0] = args;
43073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43074 if (!SWIG_IsOK(res1)) {
43075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43076 }
43077 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43078 {
43079 PyThreadState* __tstate = wxPyBeginAllowThreads();
43080 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43081 wxPyEndAllowThreads(__tstate);
43082 if (PyErr_Occurred()) SWIG_fail;
43083 }
43084 {
43085 resultobj = wxPyMake_wxObject(result, 0);
43086 }
43087 return resultobj;
43088 fail:
43089 return NULL;
43090 }
43091
43092
43093 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43094 PyObject *resultobj = 0;
43095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43096 wxMenu *arg2 = (wxMenu *) 0 ;
43097 void *argp1 = 0 ;
43098 int res1 = 0 ;
43099 void *argp2 = 0 ;
43100 int res2 = 0 ;
43101 PyObject * obj0 = 0 ;
43102 PyObject * obj1 = 0 ;
43103 char * kwnames[] = {
43104 (char *) "self",(char *) "menu", NULL
43105 };
43106
43107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43109 if (!SWIG_IsOK(res1)) {
43110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43111 }
43112 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43113 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43114 if (!SWIG_IsOK(res2)) {
43115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43116 }
43117 arg2 = reinterpret_cast< wxMenu * >(argp2);
43118 {
43119 PyThreadState* __tstate = wxPyBeginAllowThreads();
43120 (arg1)->SetMenu(arg2);
43121 wxPyEndAllowThreads(__tstate);
43122 if (PyErr_Occurred()) SWIG_fail;
43123 }
43124 resultobj = SWIG_Py_Void();
43125 return resultobj;
43126 fail:
43127 return NULL;
43128 }
43129
43130
43131 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43132 PyObject *resultobj = 0;
43133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43134 int arg2 ;
43135 void *argp1 = 0 ;
43136 int res1 = 0 ;
43137 int val2 ;
43138 int ecode2 = 0 ;
43139 PyObject * obj0 = 0 ;
43140 PyObject * obj1 = 0 ;
43141 char * kwnames[] = {
43142 (char *) "self",(char *) "id", NULL
43143 };
43144
43145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43147 if (!SWIG_IsOK(res1)) {
43148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43149 }
43150 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43151 ecode2 = SWIG_AsVal_int(obj1, &val2);
43152 if (!SWIG_IsOK(ecode2)) {
43153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43154 }
43155 arg2 = static_cast< int >(val2);
43156 {
43157 PyThreadState* __tstate = wxPyBeginAllowThreads();
43158 (arg1)->SetId(arg2);
43159 wxPyEndAllowThreads(__tstate);
43160 if (PyErr_Occurred()) SWIG_fail;
43161 }
43162 resultobj = SWIG_Py_Void();
43163 return resultobj;
43164 fail:
43165 return NULL;
43166 }
43167
43168
43169 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43170 PyObject *resultobj = 0;
43171 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43172 int result;
43173 void *argp1 = 0 ;
43174 int res1 = 0 ;
43175 PyObject *swig_obj[1] ;
43176
43177 if (!args) SWIG_fail;
43178 swig_obj[0] = args;
43179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43180 if (!SWIG_IsOK(res1)) {
43181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43182 }
43183 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43184 {
43185 PyThreadState* __tstate = wxPyBeginAllowThreads();
43186 result = (int)((wxMenuItem const *)arg1)->GetId();
43187 wxPyEndAllowThreads(__tstate);
43188 if (PyErr_Occurred()) SWIG_fail;
43189 }
43190 resultobj = SWIG_From_int(static_cast< int >(result));
43191 return resultobj;
43192 fail:
43193 return NULL;
43194 }
43195
43196
43197 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43198 PyObject *resultobj = 0;
43199 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43200 bool result;
43201 void *argp1 = 0 ;
43202 int res1 = 0 ;
43203 PyObject *swig_obj[1] ;
43204
43205 if (!args) SWIG_fail;
43206 swig_obj[0] = args;
43207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43208 if (!SWIG_IsOK(res1)) {
43209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43210 }
43211 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43215 wxPyEndAllowThreads(__tstate);
43216 if (PyErr_Occurred()) SWIG_fail;
43217 }
43218 {
43219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43220 }
43221 return resultobj;
43222 fail:
43223 return NULL;
43224 }
43225
43226
43227 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43228 PyObject *resultobj = 0;
43229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43230 wxString *arg2 = 0 ;
43231 void *argp1 = 0 ;
43232 int res1 = 0 ;
43233 bool temp2 = false ;
43234 PyObject * obj0 = 0 ;
43235 PyObject * obj1 = 0 ;
43236 char * kwnames[] = {
43237 (char *) "self",(char *) "str", NULL
43238 };
43239
43240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43242 if (!SWIG_IsOK(res1)) {
43243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43244 }
43245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43246 {
43247 arg2 = wxString_in_helper(obj1);
43248 if (arg2 == NULL) SWIG_fail;
43249 temp2 = true;
43250 }
43251 {
43252 PyThreadState* __tstate = wxPyBeginAllowThreads();
43253 (arg1)->SetText((wxString const &)*arg2);
43254 wxPyEndAllowThreads(__tstate);
43255 if (PyErr_Occurred()) SWIG_fail;
43256 }
43257 resultobj = SWIG_Py_Void();
43258 {
43259 if (temp2)
43260 delete arg2;
43261 }
43262 return resultobj;
43263 fail:
43264 {
43265 if (temp2)
43266 delete arg2;
43267 }
43268 return NULL;
43269 }
43270
43271
43272 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43273 PyObject *resultobj = 0;
43274 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43275 wxString result;
43276 void *argp1 = 0 ;
43277 int res1 = 0 ;
43278 PyObject *swig_obj[1] ;
43279
43280 if (!args) SWIG_fail;
43281 swig_obj[0] = args;
43282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43283 if (!SWIG_IsOK(res1)) {
43284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43285 }
43286 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43287 {
43288 PyThreadState* __tstate = wxPyBeginAllowThreads();
43289 result = ((wxMenuItem const *)arg1)->GetLabel();
43290 wxPyEndAllowThreads(__tstate);
43291 if (PyErr_Occurred()) SWIG_fail;
43292 }
43293 {
43294 #if wxUSE_UNICODE
43295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43296 #else
43297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43298 #endif
43299 }
43300 return resultobj;
43301 fail:
43302 return NULL;
43303 }
43304
43305
43306 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43307 PyObject *resultobj = 0;
43308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43309 wxString *result = 0 ;
43310 void *argp1 = 0 ;
43311 int res1 = 0 ;
43312 PyObject *swig_obj[1] ;
43313
43314 if (!args) SWIG_fail;
43315 swig_obj[0] = args;
43316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43317 if (!SWIG_IsOK(res1)) {
43318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43319 }
43320 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43321 {
43322 PyThreadState* __tstate = wxPyBeginAllowThreads();
43323 {
43324 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43325 result = (wxString *) &_result_ref;
43326 }
43327 wxPyEndAllowThreads(__tstate);
43328 if (PyErr_Occurred()) SWIG_fail;
43329 }
43330 {
43331 #if wxUSE_UNICODE
43332 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43333 #else
43334 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43335 #endif
43336 }
43337 return resultobj;
43338 fail:
43339 return NULL;
43340 }
43341
43342
43343 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43344 PyObject *resultobj = 0;
43345 wxString *arg1 = 0 ;
43346 wxString result;
43347 bool temp1 = false ;
43348 PyObject * obj0 = 0 ;
43349 char * kwnames[] = {
43350 (char *) "text", NULL
43351 };
43352
43353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43354 {
43355 arg1 = wxString_in_helper(obj0);
43356 if (arg1 == NULL) SWIG_fail;
43357 temp1 = true;
43358 }
43359 {
43360 PyThreadState* __tstate = wxPyBeginAllowThreads();
43361 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43362 wxPyEndAllowThreads(__tstate);
43363 if (PyErr_Occurred()) SWIG_fail;
43364 }
43365 {
43366 #if wxUSE_UNICODE
43367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43368 #else
43369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43370 #endif
43371 }
43372 {
43373 if (temp1)
43374 delete arg1;
43375 }
43376 return resultobj;
43377 fail:
43378 {
43379 if (temp1)
43380 delete arg1;
43381 }
43382 return NULL;
43383 }
43384
43385
43386 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43387 PyObject *resultobj = 0;
43388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43389 wxItemKind result;
43390 void *argp1 = 0 ;
43391 int res1 = 0 ;
43392 PyObject *swig_obj[1] ;
43393
43394 if (!args) SWIG_fail;
43395 swig_obj[0] = args;
43396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43397 if (!SWIG_IsOK(res1)) {
43398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43399 }
43400 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43401 {
43402 PyThreadState* __tstate = wxPyBeginAllowThreads();
43403 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43404 wxPyEndAllowThreads(__tstate);
43405 if (PyErr_Occurred()) SWIG_fail;
43406 }
43407 resultobj = SWIG_From_int(static_cast< int >(result));
43408 return resultobj;
43409 fail:
43410 return NULL;
43411 }
43412
43413
43414 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43415 PyObject *resultobj = 0;
43416 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43417 wxItemKind arg2 ;
43418 void *argp1 = 0 ;
43419 int res1 = 0 ;
43420 int val2 ;
43421 int ecode2 = 0 ;
43422 PyObject * obj0 = 0 ;
43423 PyObject * obj1 = 0 ;
43424 char * kwnames[] = {
43425 (char *) "self",(char *) "kind", NULL
43426 };
43427
43428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43430 if (!SWIG_IsOK(res1)) {
43431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43432 }
43433 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43434 ecode2 = SWIG_AsVal_int(obj1, &val2);
43435 if (!SWIG_IsOK(ecode2)) {
43436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43437 }
43438 arg2 = static_cast< wxItemKind >(val2);
43439 {
43440 PyThreadState* __tstate = wxPyBeginAllowThreads();
43441 (arg1)->SetKind(arg2);
43442 wxPyEndAllowThreads(__tstate);
43443 if (PyErr_Occurred()) SWIG_fail;
43444 }
43445 resultobj = SWIG_Py_Void();
43446 return resultobj;
43447 fail:
43448 return NULL;
43449 }
43450
43451
43452 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43453 PyObject *resultobj = 0;
43454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43455 bool arg2 ;
43456 void *argp1 = 0 ;
43457 int res1 = 0 ;
43458 bool val2 ;
43459 int ecode2 = 0 ;
43460 PyObject * obj0 = 0 ;
43461 PyObject * obj1 = 0 ;
43462 char * kwnames[] = {
43463 (char *) "self",(char *) "checkable", NULL
43464 };
43465
43466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43468 if (!SWIG_IsOK(res1)) {
43469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43470 }
43471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43472 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43473 if (!SWIG_IsOK(ecode2)) {
43474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43475 }
43476 arg2 = static_cast< bool >(val2);
43477 {
43478 PyThreadState* __tstate = wxPyBeginAllowThreads();
43479 (arg1)->SetCheckable(arg2);
43480 wxPyEndAllowThreads(__tstate);
43481 if (PyErr_Occurred()) SWIG_fail;
43482 }
43483 resultobj = SWIG_Py_Void();
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43491 PyObject *resultobj = 0;
43492 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43493 bool result;
43494 void *argp1 = 0 ;
43495 int res1 = 0 ;
43496 PyObject *swig_obj[1] ;
43497
43498 if (!args) SWIG_fail;
43499 swig_obj[0] = args;
43500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43501 if (!SWIG_IsOK(res1)) {
43502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43503 }
43504 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43505 {
43506 PyThreadState* __tstate = wxPyBeginAllowThreads();
43507 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43508 wxPyEndAllowThreads(__tstate);
43509 if (PyErr_Occurred()) SWIG_fail;
43510 }
43511 {
43512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43513 }
43514 return resultobj;
43515 fail:
43516 return NULL;
43517 }
43518
43519
43520 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43521 PyObject *resultobj = 0;
43522 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43523 bool result;
43524 void *argp1 = 0 ;
43525 int res1 = 0 ;
43526 PyObject *swig_obj[1] ;
43527
43528 if (!args) SWIG_fail;
43529 swig_obj[0] = args;
43530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43531 if (!SWIG_IsOK(res1)) {
43532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43533 }
43534 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43535 {
43536 PyThreadState* __tstate = wxPyBeginAllowThreads();
43537 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43538 wxPyEndAllowThreads(__tstate);
43539 if (PyErr_Occurred()) SWIG_fail;
43540 }
43541 {
43542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43543 }
43544 return resultobj;
43545 fail:
43546 return NULL;
43547 }
43548
43549
43550 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43551 PyObject *resultobj = 0;
43552 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43553 wxMenu *arg2 = (wxMenu *) 0 ;
43554 void *argp1 = 0 ;
43555 int res1 = 0 ;
43556 void *argp2 = 0 ;
43557 int res2 = 0 ;
43558 PyObject * obj0 = 0 ;
43559 PyObject * obj1 = 0 ;
43560 char * kwnames[] = {
43561 (char *) "self",(char *) "menu", NULL
43562 };
43563
43564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43566 if (!SWIG_IsOK(res1)) {
43567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43568 }
43569 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43571 if (!SWIG_IsOK(res2)) {
43572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43573 }
43574 arg2 = reinterpret_cast< wxMenu * >(argp2);
43575 {
43576 PyThreadState* __tstate = wxPyBeginAllowThreads();
43577 (arg1)->SetSubMenu(arg2);
43578 wxPyEndAllowThreads(__tstate);
43579 if (PyErr_Occurred()) SWIG_fail;
43580 }
43581 resultobj = SWIG_Py_Void();
43582 return resultobj;
43583 fail:
43584 return NULL;
43585 }
43586
43587
43588 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43589 PyObject *resultobj = 0;
43590 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43591 wxMenu *result = 0 ;
43592 void *argp1 = 0 ;
43593 int res1 = 0 ;
43594 PyObject *swig_obj[1] ;
43595
43596 if (!args) SWIG_fail;
43597 swig_obj[0] = args;
43598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43599 if (!SWIG_IsOK(res1)) {
43600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43601 }
43602 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43603 {
43604 PyThreadState* __tstate = wxPyBeginAllowThreads();
43605 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43606 wxPyEndAllowThreads(__tstate);
43607 if (PyErr_Occurred()) SWIG_fail;
43608 }
43609 {
43610 resultobj = wxPyMake_wxObject(result, 0);
43611 }
43612 return resultobj;
43613 fail:
43614 return NULL;
43615 }
43616
43617
43618 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43619 PyObject *resultobj = 0;
43620 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43621 bool arg2 = (bool) true ;
43622 void *argp1 = 0 ;
43623 int res1 = 0 ;
43624 bool val2 ;
43625 int ecode2 = 0 ;
43626 PyObject * obj0 = 0 ;
43627 PyObject * obj1 = 0 ;
43628 char * kwnames[] = {
43629 (char *) "self",(char *) "enable", NULL
43630 };
43631
43632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43634 if (!SWIG_IsOK(res1)) {
43635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43636 }
43637 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43638 if (obj1) {
43639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43640 if (!SWIG_IsOK(ecode2)) {
43641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43642 }
43643 arg2 = static_cast< bool >(val2);
43644 }
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 (arg1)->Enable(arg2);
43648 wxPyEndAllowThreads(__tstate);
43649 if (PyErr_Occurred()) SWIG_fail;
43650 }
43651 resultobj = SWIG_Py_Void();
43652 return resultobj;
43653 fail:
43654 return NULL;
43655 }
43656
43657
43658 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43659 PyObject *resultobj = 0;
43660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43661 bool result;
43662 void *argp1 = 0 ;
43663 int res1 = 0 ;
43664 PyObject *swig_obj[1] ;
43665
43666 if (!args) SWIG_fail;
43667 swig_obj[0] = args;
43668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43669 if (!SWIG_IsOK(res1)) {
43670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43671 }
43672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43676 wxPyEndAllowThreads(__tstate);
43677 if (PyErr_Occurred()) SWIG_fail;
43678 }
43679 {
43680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43681 }
43682 return resultobj;
43683 fail:
43684 return NULL;
43685 }
43686
43687
43688 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43689 PyObject *resultobj = 0;
43690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43691 bool arg2 = (bool) true ;
43692 void *argp1 = 0 ;
43693 int res1 = 0 ;
43694 bool val2 ;
43695 int ecode2 = 0 ;
43696 PyObject * obj0 = 0 ;
43697 PyObject * obj1 = 0 ;
43698 char * kwnames[] = {
43699 (char *) "self",(char *) "check", NULL
43700 };
43701
43702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43704 if (!SWIG_IsOK(res1)) {
43705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43706 }
43707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43708 if (obj1) {
43709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43710 if (!SWIG_IsOK(ecode2)) {
43711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43712 }
43713 arg2 = static_cast< bool >(val2);
43714 }
43715 {
43716 PyThreadState* __tstate = wxPyBeginAllowThreads();
43717 (arg1)->Check(arg2);
43718 wxPyEndAllowThreads(__tstate);
43719 if (PyErr_Occurred()) SWIG_fail;
43720 }
43721 resultobj = SWIG_Py_Void();
43722 return resultobj;
43723 fail:
43724 return NULL;
43725 }
43726
43727
43728 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(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_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43741 }
43742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43743 {
43744 PyThreadState* __tstate = wxPyBeginAllowThreads();
43745 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
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_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43759 PyObject *resultobj = 0;
43760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43761 void *argp1 = 0 ;
43762 int res1 = 0 ;
43763 PyObject *swig_obj[1] ;
43764
43765 if (!args) SWIG_fail;
43766 swig_obj[0] = args;
43767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43768 if (!SWIG_IsOK(res1)) {
43769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43770 }
43771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43772 {
43773 PyThreadState* __tstate = wxPyBeginAllowThreads();
43774 (arg1)->Toggle();
43775 wxPyEndAllowThreads(__tstate);
43776 if (PyErr_Occurred()) SWIG_fail;
43777 }
43778 resultobj = SWIG_Py_Void();
43779 return resultobj;
43780 fail:
43781 return NULL;
43782 }
43783
43784
43785 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43786 PyObject *resultobj = 0;
43787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43788 wxString *arg2 = 0 ;
43789 void *argp1 = 0 ;
43790 int res1 = 0 ;
43791 bool temp2 = false ;
43792 PyObject * obj0 = 0 ;
43793 PyObject * obj1 = 0 ;
43794 char * kwnames[] = {
43795 (char *) "self",(char *) "str", NULL
43796 };
43797
43798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43800 if (!SWIG_IsOK(res1)) {
43801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43802 }
43803 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43804 {
43805 arg2 = wxString_in_helper(obj1);
43806 if (arg2 == NULL) SWIG_fail;
43807 temp2 = true;
43808 }
43809 {
43810 PyThreadState* __tstate = wxPyBeginAllowThreads();
43811 (arg1)->SetHelp((wxString const &)*arg2);
43812 wxPyEndAllowThreads(__tstate);
43813 if (PyErr_Occurred()) SWIG_fail;
43814 }
43815 resultobj = SWIG_Py_Void();
43816 {
43817 if (temp2)
43818 delete arg2;
43819 }
43820 return resultobj;
43821 fail:
43822 {
43823 if (temp2)
43824 delete arg2;
43825 }
43826 return NULL;
43827 }
43828
43829
43830 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43831 PyObject *resultobj = 0;
43832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43833 wxString *result = 0 ;
43834 void *argp1 = 0 ;
43835 int res1 = 0 ;
43836 PyObject *swig_obj[1] ;
43837
43838 if (!args) SWIG_fail;
43839 swig_obj[0] = args;
43840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43841 if (!SWIG_IsOK(res1)) {
43842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43843 }
43844 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43845 {
43846 PyThreadState* __tstate = wxPyBeginAllowThreads();
43847 {
43848 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43849 result = (wxString *) &_result_ref;
43850 }
43851 wxPyEndAllowThreads(__tstate);
43852 if (PyErr_Occurred()) SWIG_fail;
43853 }
43854 {
43855 #if wxUSE_UNICODE
43856 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43857 #else
43858 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43859 #endif
43860 }
43861 return resultobj;
43862 fail:
43863 return NULL;
43864 }
43865
43866
43867 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43868 PyObject *resultobj = 0;
43869 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43870 wxAcceleratorEntry *result = 0 ;
43871 void *argp1 = 0 ;
43872 int res1 = 0 ;
43873 PyObject *swig_obj[1] ;
43874
43875 if (!args) SWIG_fail;
43876 swig_obj[0] = args;
43877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43878 if (!SWIG_IsOK(res1)) {
43879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43880 }
43881 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43882 {
43883 PyThreadState* __tstate = wxPyBeginAllowThreads();
43884 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43885 wxPyEndAllowThreads(__tstate);
43886 if (PyErr_Occurred()) SWIG_fail;
43887 }
43888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43889 return resultobj;
43890 fail:
43891 return NULL;
43892 }
43893
43894
43895 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43896 PyObject *resultobj = 0;
43897 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43898 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43899 void *argp1 = 0 ;
43900 int res1 = 0 ;
43901 void *argp2 = 0 ;
43902 int res2 = 0 ;
43903 PyObject * obj0 = 0 ;
43904 PyObject * obj1 = 0 ;
43905 char * kwnames[] = {
43906 (char *) "self",(char *) "accel", NULL
43907 };
43908
43909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43911 if (!SWIG_IsOK(res1)) {
43912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43913 }
43914 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43916 if (!SWIG_IsOK(res2)) {
43917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43918 }
43919 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43920 {
43921 PyThreadState* __tstate = wxPyBeginAllowThreads();
43922 (arg1)->SetAccel(arg2);
43923 wxPyEndAllowThreads(__tstate);
43924 if (PyErr_Occurred()) SWIG_fail;
43925 }
43926 resultobj = SWIG_Py_Void();
43927 return resultobj;
43928 fail:
43929 return NULL;
43930 }
43931
43932
43933 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43934 PyObject *resultobj = 0;
43935 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43936 wxBitmap *arg2 = 0 ;
43937 void *argp1 = 0 ;
43938 int res1 = 0 ;
43939 void *argp2 = 0 ;
43940 int res2 = 0 ;
43941 PyObject * obj0 = 0 ;
43942 PyObject * obj1 = 0 ;
43943 char * kwnames[] = {
43944 (char *) "self",(char *) "bitmap", NULL
43945 };
43946
43947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43949 if (!SWIG_IsOK(res1)) {
43950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43951 }
43952 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43954 if (!SWIG_IsOK(res2)) {
43955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43956 }
43957 if (!argp2) {
43958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43959 }
43960 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43961 {
43962 PyThreadState* __tstate = wxPyBeginAllowThreads();
43963 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 resultobj = SWIG_Py_Void();
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43975 PyObject *resultobj = 0;
43976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43977 wxBitmap *result = 0 ;
43978 void *argp1 = 0 ;
43979 int res1 = 0 ;
43980 PyObject *swig_obj[1] ;
43981
43982 if (!args) SWIG_fail;
43983 swig_obj[0] = args;
43984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43985 if (!SWIG_IsOK(res1)) {
43986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43987 }
43988 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43989 {
43990 PyThreadState* __tstate = wxPyBeginAllowThreads();
43991 {
43992 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43993 result = (wxBitmap *) &_result_ref;
43994 }
43995 wxPyEndAllowThreads(__tstate);
43996 if (PyErr_Occurred()) SWIG_fail;
43997 }
43998 {
43999 wxBitmap* resultptr = new wxBitmap(*result);
44000 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44001 }
44002 return resultobj;
44003 fail:
44004 return NULL;
44005 }
44006
44007
44008 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44009 PyObject *resultobj = 0;
44010 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44011 wxFont *arg2 = 0 ;
44012 void *argp1 = 0 ;
44013 int res1 = 0 ;
44014 void *argp2 = 0 ;
44015 int res2 = 0 ;
44016 PyObject * obj0 = 0 ;
44017 PyObject * obj1 = 0 ;
44018 char * kwnames[] = {
44019 (char *) "self",(char *) "font", NULL
44020 };
44021
44022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44024 if (!SWIG_IsOK(res1)) {
44025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44026 }
44027 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44028 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44029 if (!SWIG_IsOK(res2)) {
44030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44031 }
44032 if (!argp2) {
44033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44034 }
44035 arg2 = reinterpret_cast< wxFont * >(argp2);
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 (arg1)->SetFont((wxFont const &)*arg2);
44039 wxPyEndAllowThreads(__tstate);
44040 if (PyErr_Occurred()) SWIG_fail;
44041 }
44042 resultobj = SWIG_Py_Void();
44043 return resultobj;
44044 fail:
44045 return NULL;
44046 }
44047
44048
44049 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44050 PyObject *resultobj = 0;
44051 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44052 wxFont result;
44053 void *argp1 = 0 ;
44054 int res1 = 0 ;
44055 PyObject *swig_obj[1] ;
44056
44057 if (!args) SWIG_fail;
44058 swig_obj[0] = args;
44059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44060 if (!SWIG_IsOK(res1)) {
44061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44062 }
44063 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44064 {
44065 PyThreadState* __tstate = wxPyBeginAllowThreads();
44066 result = (arg1)->GetFont();
44067 wxPyEndAllowThreads(__tstate);
44068 if (PyErr_Occurred()) SWIG_fail;
44069 }
44070 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44071 return resultobj;
44072 fail:
44073 return NULL;
44074 }
44075
44076
44077 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44078 PyObject *resultobj = 0;
44079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44080 wxColour *arg2 = 0 ;
44081 void *argp1 = 0 ;
44082 int res1 = 0 ;
44083 wxColour temp2 ;
44084 PyObject * obj0 = 0 ;
44085 PyObject * obj1 = 0 ;
44086 char * kwnames[] = {
44087 (char *) "self",(char *) "colText", NULL
44088 };
44089
44090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44092 if (!SWIG_IsOK(res1)) {
44093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44094 }
44095 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44096 {
44097 arg2 = &temp2;
44098 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44099 }
44100 {
44101 PyThreadState* __tstate = wxPyBeginAllowThreads();
44102 (arg1)->SetTextColour((wxColour const &)*arg2);
44103 wxPyEndAllowThreads(__tstate);
44104 if (PyErr_Occurred()) SWIG_fail;
44105 }
44106 resultobj = SWIG_Py_Void();
44107 return resultobj;
44108 fail:
44109 return NULL;
44110 }
44111
44112
44113 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44114 PyObject *resultobj = 0;
44115 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44116 wxColour result;
44117 void *argp1 = 0 ;
44118 int res1 = 0 ;
44119 PyObject *swig_obj[1] ;
44120
44121 if (!args) SWIG_fail;
44122 swig_obj[0] = args;
44123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44124 if (!SWIG_IsOK(res1)) {
44125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44126 }
44127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44128 {
44129 PyThreadState* __tstate = wxPyBeginAllowThreads();
44130 result = (arg1)->GetTextColour();
44131 wxPyEndAllowThreads(__tstate);
44132 if (PyErr_Occurred()) SWIG_fail;
44133 }
44134 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44135 return resultobj;
44136 fail:
44137 return NULL;
44138 }
44139
44140
44141 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44142 PyObject *resultobj = 0;
44143 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44144 wxColour *arg2 = 0 ;
44145 void *argp1 = 0 ;
44146 int res1 = 0 ;
44147 wxColour temp2 ;
44148 PyObject * obj0 = 0 ;
44149 PyObject * obj1 = 0 ;
44150 char * kwnames[] = {
44151 (char *) "self",(char *) "colBack", NULL
44152 };
44153
44154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44156 if (!SWIG_IsOK(res1)) {
44157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44158 }
44159 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44160 {
44161 arg2 = &temp2;
44162 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44163 }
44164 {
44165 PyThreadState* __tstate = wxPyBeginAllowThreads();
44166 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44167 wxPyEndAllowThreads(__tstate);
44168 if (PyErr_Occurred()) SWIG_fail;
44169 }
44170 resultobj = SWIG_Py_Void();
44171 return resultobj;
44172 fail:
44173 return NULL;
44174 }
44175
44176
44177 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44178 PyObject *resultobj = 0;
44179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44180 wxColour result;
44181 void *argp1 = 0 ;
44182 int res1 = 0 ;
44183 PyObject *swig_obj[1] ;
44184
44185 if (!args) SWIG_fail;
44186 swig_obj[0] = args;
44187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44188 if (!SWIG_IsOK(res1)) {
44189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44190 }
44191 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44192 {
44193 PyThreadState* __tstate = wxPyBeginAllowThreads();
44194 result = (arg1)->GetBackgroundColour();
44195 wxPyEndAllowThreads(__tstate);
44196 if (PyErr_Occurred()) SWIG_fail;
44197 }
44198 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44199 return resultobj;
44200 fail:
44201 return NULL;
44202 }
44203
44204
44205 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44206 PyObject *resultobj = 0;
44207 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44208 wxBitmap *arg2 = 0 ;
44209 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44210 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44211 void *argp1 = 0 ;
44212 int res1 = 0 ;
44213 void *argp2 = 0 ;
44214 int res2 = 0 ;
44215 void *argp3 = 0 ;
44216 int res3 = 0 ;
44217 PyObject * obj0 = 0 ;
44218 PyObject * obj1 = 0 ;
44219 PyObject * obj2 = 0 ;
44220 char * kwnames[] = {
44221 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44222 };
44223
44224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44226 if (!SWIG_IsOK(res1)) {
44227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44228 }
44229 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44231 if (!SWIG_IsOK(res2)) {
44232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44233 }
44234 if (!argp2) {
44235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44236 }
44237 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44238 if (obj2) {
44239 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44240 if (!SWIG_IsOK(res3)) {
44241 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44242 }
44243 if (!argp3) {
44244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44245 }
44246 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44247 }
44248 {
44249 PyThreadState* __tstate = wxPyBeginAllowThreads();
44250 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44251 wxPyEndAllowThreads(__tstate);
44252 if (PyErr_Occurred()) SWIG_fail;
44253 }
44254 resultobj = SWIG_Py_Void();
44255 return resultobj;
44256 fail:
44257 return NULL;
44258 }
44259
44260
44261 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44262 PyObject *resultobj = 0;
44263 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44264 wxBitmap *arg2 = 0 ;
44265 void *argp1 = 0 ;
44266 int res1 = 0 ;
44267 void *argp2 = 0 ;
44268 int res2 = 0 ;
44269 PyObject * obj0 = 0 ;
44270 PyObject * obj1 = 0 ;
44271 char * kwnames[] = {
44272 (char *) "self",(char *) "bmpDisabled", NULL
44273 };
44274
44275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44277 if (!SWIG_IsOK(res1)) {
44278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44279 }
44280 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44281 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44282 if (!SWIG_IsOK(res2)) {
44283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44284 }
44285 if (!argp2) {
44286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44287 }
44288 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44292 wxPyEndAllowThreads(__tstate);
44293 if (PyErr_Occurred()) SWIG_fail;
44294 }
44295 resultobj = SWIG_Py_Void();
44296 return resultobj;
44297 fail:
44298 return NULL;
44299 }
44300
44301
44302 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44303 PyObject *resultobj = 0;
44304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44305 wxBitmap *result = 0 ;
44306 void *argp1 = 0 ;
44307 int res1 = 0 ;
44308 PyObject *swig_obj[1] ;
44309
44310 if (!args) SWIG_fail;
44311 swig_obj[0] = args;
44312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44313 if (!SWIG_IsOK(res1)) {
44314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44315 }
44316 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44317 {
44318 PyThreadState* __tstate = wxPyBeginAllowThreads();
44319 {
44320 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44321 result = (wxBitmap *) &_result_ref;
44322 }
44323 wxPyEndAllowThreads(__tstate);
44324 if (PyErr_Occurred()) SWIG_fail;
44325 }
44326 {
44327 wxBitmap* resultptr = new wxBitmap(*result);
44328 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44329 }
44330 return resultobj;
44331 fail:
44332 return NULL;
44333 }
44334
44335
44336 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44337 PyObject *resultobj = 0;
44338 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44339 int arg2 ;
44340 void *argp1 = 0 ;
44341 int res1 = 0 ;
44342 int val2 ;
44343 int ecode2 = 0 ;
44344 PyObject * obj0 = 0 ;
44345 PyObject * obj1 = 0 ;
44346 char * kwnames[] = {
44347 (char *) "self",(char *) "nWidth", NULL
44348 };
44349
44350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44352 if (!SWIG_IsOK(res1)) {
44353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44354 }
44355 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44356 ecode2 = SWIG_AsVal_int(obj1, &val2);
44357 if (!SWIG_IsOK(ecode2)) {
44358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44359 }
44360 arg2 = static_cast< int >(val2);
44361 {
44362 PyThreadState* __tstate = wxPyBeginAllowThreads();
44363 (arg1)->SetMarginWidth(arg2);
44364 wxPyEndAllowThreads(__tstate);
44365 if (PyErr_Occurred()) SWIG_fail;
44366 }
44367 resultobj = SWIG_Py_Void();
44368 return resultobj;
44369 fail:
44370 return NULL;
44371 }
44372
44373
44374 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44375 PyObject *resultobj = 0;
44376 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44377 int result;
44378 void *argp1 = 0 ;
44379 int res1 = 0 ;
44380 PyObject *swig_obj[1] ;
44381
44382 if (!args) SWIG_fail;
44383 swig_obj[0] = args;
44384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44385 if (!SWIG_IsOK(res1)) {
44386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44387 }
44388 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44389 {
44390 PyThreadState* __tstate = wxPyBeginAllowThreads();
44391 result = (int)(arg1)->GetMarginWidth();
44392 wxPyEndAllowThreads(__tstate);
44393 if (PyErr_Occurred()) SWIG_fail;
44394 }
44395 resultobj = SWIG_From_int(static_cast< int >(result));
44396 return resultobj;
44397 fail:
44398 return NULL;
44399 }
44400
44401
44402 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44403 PyObject *resultobj = 0;
44404 int result;
44405
44406 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44407 {
44408 PyThreadState* __tstate = wxPyBeginAllowThreads();
44409 result = (int)wxMenuItem::GetDefaultMarginWidth();
44410 wxPyEndAllowThreads(__tstate);
44411 if (PyErr_Occurred()) SWIG_fail;
44412 }
44413 resultobj = SWIG_From_int(static_cast< int >(result));
44414 return resultobj;
44415 fail:
44416 return NULL;
44417 }
44418
44419
44420 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44421 PyObject *resultobj = 0;
44422 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44423 bool result;
44424 void *argp1 = 0 ;
44425 int res1 = 0 ;
44426 PyObject *swig_obj[1] ;
44427
44428 if (!args) SWIG_fail;
44429 swig_obj[0] = args;
44430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44431 if (!SWIG_IsOK(res1)) {
44432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44433 }
44434 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44435 {
44436 PyThreadState* __tstate = wxPyBeginAllowThreads();
44437 result = (bool)(arg1)->IsOwnerDrawn();
44438 wxPyEndAllowThreads(__tstate);
44439 if (PyErr_Occurred()) SWIG_fail;
44440 }
44441 {
44442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44443 }
44444 return resultobj;
44445 fail:
44446 return NULL;
44447 }
44448
44449
44450 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44451 PyObject *resultobj = 0;
44452 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44453 bool arg2 = (bool) true ;
44454 void *argp1 = 0 ;
44455 int res1 = 0 ;
44456 bool val2 ;
44457 int ecode2 = 0 ;
44458 PyObject * obj0 = 0 ;
44459 PyObject * obj1 = 0 ;
44460 char * kwnames[] = {
44461 (char *) "self",(char *) "ownerDrawn", NULL
44462 };
44463
44464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44466 if (!SWIG_IsOK(res1)) {
44467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44468 }
44469 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44470 if (obj1) {
44471 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44472 if (!SWIG_IsOK(ecode2)) {
44473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44474 }
44475 arg2 = static_cast< bool >(val2);
44476 }
44477 {
44478 PyThreadState* __tstate = wxPyBeginAllowThreads();
44479 (arg1)->SetOwnerDrawn(arg2);
44480 wxPyEndAllowThreads(__tstate);
44481 if (PyErr_Occurred()) SWIG_fail;
44482 }
44483 resultobj = SWIG_Py_Void();
44484 return resultobj;
44485 fail:
44486 return NULL;
44487 }
44488
44489
44490 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44491 PyObject *resultobj = 0;
44492 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44493 void *argp1 = 0 ;
44494 int res1 = 0 ;
44495 PyObject *swig_obj[1] ;
44496
44497 if (!args) SWIG_fail;
44498 swig_obj[0] = args;
44499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44500 if (!SWIG_IsOK(res1)) {
44501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44502 }
44503 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44504 {
44505 PyThreadState* __tstate = wxPyBeginAllowThreads();
44506 (arg1)->ResetOwnerDrawn();
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 resultobj = SWIG_Py_Void();
44511 return resultobj;
44512 fail:
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44518 PyObject *obj;
44519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44520 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44521 return SWIG_Py_Void();
44522 }
44523
44524 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44525 return SWIG_Python_InitShadowInstance(args);
44526 }
44527
44528 SWIGINTERN int ControlNameStr_set(PyObject *) {
44529 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44530 return 1;
44531 }
44532
44533
44534 SWIGINTERN PyObject *ControlNameStr_get(void) {
44535 PyObject *pyobj = 0;
44536
44537 {
44538 #if wxUSE_UNICODE
44539 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44540 #else
44541 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44542 #endif
44543 }
44544 return pyobj;
44545 }
44546
44547
44548 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44549 PyObject *resultobj = 0;
44550 wxWindow *arg1 = (wxWindow *) 0 ;
44551 int arg2 = (int) -1 ;
44552 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44553 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44554 wxSize const &arg4_defvalue = wxDefaultSize ;
44555 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44556 long arg5 = (long) 0 ;
44557 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44558 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44559 wxString const &arg7_defvalue = wxPyControlNameStr ;
44560 wxString *arg7 = (wxString *) &arg7_defvalue ;
44561 wxControl *result = 0 ;
44562 void *argp1 = 0 ;
44563 int res1 = 0 ;
44564 int val2 ;
44565 int ecode2 = 0 ;
44566 wxPoint temp3 ;
44567 wxSize temp4 ;
44568 long val5 ;
44569 int ecode5 = 0 ;
44570 void *argp6 = 0 ;
44571 int res6 = 0 ;
44572 bool temp7 = false ;
44573 PyObject * obj0 = 0 ;
44574 PyObject * obj1 = 0 ;
44575 PyObject * obj2 = 0 ;
44576 PyObject * obj3 = 0 ;
44577 PyObject * obj4 = 0 ;
44578 PyObject * obj5 = 0 ;
44579 PyObject * obj6 = 0 ;
44580 char * kwnames[] = {
44581 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44582 };
44583
44584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44586 if (!SWIG_IsOK(res1)) {
44587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44588 }
44589 arg1 = reinterpret_cast< wxWindow * >(argp1);
44590 if (obj1) {
44591 ecode2 = SWIG_AsVal_int(obj1, &val2);
44592 if (!SWIG_IsOK(ecode2)) {
44593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44594 }
44595 arg2 = static_cast< int >(val2);
44596 }
44597 if (obj2) {
44598 {
44599 arg3 = &temp3;
44600 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44601 }
44602 }
44603 if (obj3) {
44604 {
44605 arg4 = &temp4;
44606 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44607 }
44608 }
44609 if (obj4) {
44610 ecode5 = SWIG_AsVal_long(obj4, &val5);
44611 if (!SWIG_IsOK(ecode5)) {
44612 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44613 }
44614 arg5 = static_cast< long >(val5);
44615 }
44616 if (obj5) {
44617 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44618 if (!SWIG_IsOK(res6)) {
44619 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44620 }
44621 if (!argp6) {
44622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44623 }
44624 arg6 = reinterpret_cast< wxValidator * >(argp6);
44625 }
44626 if (obj6) {
44627 {
44628 arg7 = wxString_in_helper(obj6);
44629 if (arg7 == NULL) SWIG_fail;
44630 temp7 = true;
44631 }
44632 }
44633 {
44634 if (!wxPyCheckForApp()) SWIG_fail;
44635 PyThreadState* __tstate = wxPyBeginAllowThreads();
44636 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44637 wxPyEndAllowThreads(__tstate);
44638 if (PyErr_Occurred()) SWIG_fail;
44639 }
44640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44641 {
44642 if (temp7)
44643 delete arg7;
44644 }
44645 return resultobj;
44646 fail:
44647 {
44648 if (temp7)
44649 delete arg7;
44650 }
44651 return NULL;
44652 }
44653
44654
44655 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44656 PyObject *resultobj = 0;
44657 wxControl *result = 0 ;
44658
44659 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44660 {
44661 if (!wxPyCheckForApp()) SWIG_fail;
44662 PyThreadState* __tstate = wxPyBeginAllowThreads();
44663 result = (wxControl *)new wxControl();
44664 wxPyEndAllowThreads(__tstate);
44665 if (PyErr_Occurred()) SWIG_fail;
44666 }
44667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44668 return resultobj;
44669 fail:
44670 return NULL;
44671 }
44672
44673
44674 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44675 PyObject *resultobj = 0;
44676 wxControl *arg1 = (wxControl *) 0 ;
44677 wxWindow *arg2 = (wxWindow *) 0 ;
44678 int arg3 = (int) -1 ;
44679 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44680 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44681 wxSize const &arg5_defvalue = wxDefaultSize ;
44682 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44683 long arg6 = (long) 0 ;
44684 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44685 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44686 wxString const &arg8_defvalue = wxPyControlNameStr ;
44687 wxString *arg8 = (wxString *) &arg8_defvalue ;
44688 bool result;
44689 void *argp1 = 0 ;
44690 int res1 = 0 ;
44691 void *argp2 = 0 ;
44692 int res2 = 0 ;
44693 int val3 ;
44694 int ecode3 = 0 ;
44695 wxPoint temp4 ;
44696 wxSize temp5 ;
44697 long val6 ;
44698 int ecode6 = 0 ;
44699 void *argp7 = 0 ;
44700 int res7 = 0 ;
44701 bool temp8 = false ;
44702 PyObject * obj0 = 0 ;
44703 PyObject * obj1 = 0 ;
44704 PyObject * obj2 = 0 ;
44705 PyObject * obj3 = 0 ;
44706 PyObject * obj4 = 0 ;
44707 PyObject * obj5 = 0 ;
44708 PyObject * obj6 = 0 ;
44709 PyObject * obj7 = 0 ;
44710 char * kwnames[] = {
44711 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44712 };
44713
44714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44716 if (!SWIG_IsOK(res1)) {
44717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44718 }
44719 arg1 = reinterpret_cast< wxControl * >(argp1);
44720 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44721 if (!SWIG_IsOK(res2)) {
44722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44723 }
44724 arg2 = reinterpret_cast< wxWindow * >(argp2);
44725 if (obj2) {
44726 ecode3 = SWIG_AsVal_int(obj2, &val3);
44727 if (!SWIG_IsOK(ecode3)) {
44728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44729 }
44730 arg3 = static_cast< int >(val3);
44731 }
44732 if (obj3) {
44733 {
44734 arg4 = &temp4;
44735 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44736 }
44737 }
44738 if (obj4) {
44739 {
44740 arg5 = &temp5;
44741 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44742 }
44743 }
44744 if (obj5) {
44745 ecode6 = SWIG_AsVal_long(obj5, &val6);
44746 if (!SWIG_IsOK(ecode6)) {
44747 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44748 }
44749 arg6 = static_cast< long >(val6);
44750 }
44751 if (obj6) {
44752 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44753 if (!SWIG_IsOK(res7)) {
44754 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44755 }
44756 if (!argp7) {
44757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44758 }
44759 arg7 = reinterpret_cast< wxValidator * >(argp7);
44760 }
44761 if (obj7) {
44762 {
44763 arg8 = wxString_in_helper(obj7);
44764 if (arg8 == NULL) SWIG_fail;
44765 temp8 = true;
44766 }
44767 }
44768 {
44769 PyThreadState* __tstate = wxPyBeginAllowThreads();
44770 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44771 wxPyEndAllowThreads(__tstate);
44772 if (PyErr_Occurred()) SWIG_fail;
44773 }
44774 {
44775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44776 }
44777 {
44778 if (temp8)
44779 delete arg8;
44780 }
44781 return resultobj;
44782 fail:
44783 {
44784 if (temp8)
44785 delete arg8;
44786 }
44787 return NULL;
44788 }
44789
44790
44791 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44792 PyObject *resultobj = 0;
44793 wxControl *arg1 = (wxControl *) 0 ;
44794 int result;
44795 void *argp1 = 0 ;
44796 int res1 = 0 ;
44797 PyObject *swig_obj[1] ;
44798
44799 if (!args) SWIG_fail;
44800 swig_obj[0] = args;
44801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44802 if (!SWIG_IsOK(res1)) {
44803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44804 }
44805 arg1 = reinterpret_cast< wxControl * >(argp1);
44806 {
44807 PyThreadState* __tstate = wxPyBeginAllowThreads();
44808 result = (int)((wxControl const *)arg1)->GetAlignment();
44809 wxPyEndAllowThreads(__tstate);
44810 if (PyErr_Occurred()) SWIG_fail;
44811 }
44812 resultobj = SWIG_From_int(static_cast< int >(result));
44813 return resultobj;
44814 fail:
44815 return NULL;
44816 }
44817
44818
44819 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44820 PyObject *resultobj = 0;
44821 wxControl *arg1 = (wxControl *) 0 ;
44822 wxString result;
44823 void *argp1 = 0 ;
44824 int res1 = 0 ;
44825 PyObject *swig_obj[1] ;
44826
44827 if (!args) SWIG_fail;
44828 swig_obj[0] = args;
44829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44830 if (!SWIG_IsOK(res1)) {
44831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44832 }
44833 arg1 = reinterpret_cast< wxControl * >(argp1);
44834 {
44835 PyThreadState* __tstate = wxPyBeginAllowThreads();
44836 result = ((wxControl const *)arg1)->GetLabelText();
44837 wxPyEndAllowThreads(__tstate);
44838 if (PyErr_Occurred()) SWIG_fail;
44839 }
44840 {
44841 #if wxUSE_UNICODE
44842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44843 #else
44844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44845 #endif
44846 }
44847 return resultobj;
44848 fail:
44849 return NULL;
44850 }
44851
44852
44853 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44854 PyObject *resultobj = 0;
44855 wxControl *arg1 = (wxControl *) 0 ;
44856 wxCommandEvent *arg2 = 0 ;
44857 void *argp1 = 0 ;
44858 int res1 = 0 ;
44859 void *argp2 = 0 ;
44860 int res2 = 0 ;
44861 PyObject * obj0 = 0 ;
44862 PyObject * obj1 = 0 ;
44863 char * kwnames[] = {
44864 (char *) "self",(char *) "event", NULL
44865 };
44866
44867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44869 if (!SWIG_IsOK(res1)) {
44870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44871 }
44872 arg1 = reinterpret_cast< wxControl * >(argp1);
44873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44874 if (!SWIG_IsOK(res2)) {
44875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44876 }
44877 if (!argp2) {
44878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44879 }
44880 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44881 {
44882 PyThreadState* __tstate = wxPyBeginAllowThreads();
44883 (arg1)->Command(*arg2);
44884 wxPyEndAllowThreads(__tstate);
44885 if (PyErr_Occurred()) SWIG_fail;
44886 }
44887 resultobj = SWIG_Py_Void();
44888 return resultobj;
44889 fail:
44890 return NULL;
44891 }
44892
44893
44894 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44895 PyObject *resultobj = 0;
44896 wxControl *arg1 = (wxControl *) 0 ;
44897 wxString result;
44898 void *argp1 = 0 ;
44899 int res1 = 0 ;
44900 PyObject *swig_obj[1] ;
44901
44902 if (!args) SWIG_fail;
44903 swig_obj[0] = args;
44904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44905 if (!SWIG_IsOK(res1)) {
44906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44907 }
44908 arg1 = reinterpret_cast< wxControl * >(argp1);
44909 {
44910 PyThreadState* __tstate = wxPyBeginAllowThreads();
44911 result = (arg1)->GetLabel();
44912 wxPyEndAllowThreads(__tstate);
44913 if (PyErr_Occurred()) SWIG_fail;
44914 }
44915 {
44916 #if wxUSE_UNICODE
44917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44918 #else
44919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44920 #endif
44921 }
44922 return resultobj;
44923 fail:
44924 return NULL;
44925 }
44926
44927
44928 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44929 PyObject *resultobj = 0;
44930 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44931 SwigValueWrapper<wxVisualAttributes > result;
44932 int val1 ;
44933 int ecode1 = 0 ;
44934 PyObject * obj0 = 0 ;
44935 char * kwnames[] = {
44936 (char *) "variant", NULL
44937 };
44938
44939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44940 if (obj0) {
44941 ecode1 = SWIG_AsVal_int(obj0, &val1);
44942 if (!SWIG_IsOK(ecode1)) {
44943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44944 }
44945 arg1 = static_cast< wxWindowVariant >(val1);
44946 }
44947 {
44948 if (!wxPyCheckForApp()) SWIG_fail;
44949 PyThreadState* __tstate = wxPyBeginAllowThreads();
44950 result = wxControl::GetClassDefaultAttributes(arg1);
44951 wxPyEndAllowThreads(__tstate);
44952 if (PyErr_Occurred()) SWIG_fail;
44953 }
44954 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44955 return resultobj;
44956 fail:
44957 return NULL;
44958 }
44959
44960
44961 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44962 PyObject *obj;
44963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44964 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44965 return SWIG_Py_Void();
44966 }
44967
44968 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44969 return SWIG_Python_InitShadowInstance(args);
44970 }
44971
44972 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44973 PyObject *resultobj = 0;
44974 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44975 wxString *arg2 = 0 ;
44976 PyObject *arg3 = (PyObject *) NULL ;
44977 int result;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 bool temp2 = false ;
44981 PyObject * obj0 = 0 ;
44982 PyObject * obj1 = 0 ;
44983 PyObject * obj2 = 0 ;
44984 char * kwnames[] = {
44985 (char *) "self",(char *) "item",(char *) "clientData", NULL
44986 };
44987
44988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44990 if (!SWIG_IsOK(res1)) {
44991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44992 }
44993 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44994 {
44995 arg2 = wxString_in_helper(obj1);
44996 if (arg2 == NULL) SWIG_fail;
44997 temp2 = true;
44998 }
44999 if (obj2) {
45000 arg3 = obj2;
45001 }
45002 {
45003 PyThreadState* __tstate = wxPyBeginAllowThreads();
45004 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45005 wxPyEndAllowThreads(__tstate);
45006 if (PyErr_Occurred()) SWIG_fail;
45007 }
45008 resultobj = SWIG_From_int(static_cast< int >(result));
45009 {
45010 if (temp2)
45011 delete arg2;
45012 }
45013 return resultobj;
45014 fail:
45015 {
45016 if (temp2)
45017 delete arg2;
45018 }
45019 return NULL;
45020 }
45021
45022
45023 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45024 PyObject *resultobj = 0;
45025 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45026 wxArrayString *arg2 = 0 ;
45027 void *argp1 = 0 ;
45028 int res1 = 0 ;
45029 bool temp2 = false ;
45030 PyObject * obj0 = 0 ;
45031 PyObject * obj1 = 0 ;
45032 char * kwnames[] = {
45033 (char *) "self",(char *) "strings", NULL
45034 };
45035
45036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45038 if (!SWIG_IsOK(res1)) {
45039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45040 }
45041 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45042 {
45043 if (! PySequence_Check(obj1)) {
45044 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45045 SWIG_fail;
45046 }
45047 arg2 = new wxArrayString;
45048 temp2 = true;
45049 int i, len=PySequence_Length(obj1);
45050 for (i=0; i<len; i++) {
45051 PyObject* item = PySequence_GetItem(obj1, i);
45052 wxString* s = wxString_in_helper(item);
45053 if (PyErr_Occurred()) SWIG_fail;
45054 arg2->Add(*s);
45055 delete s;
45056 Py_DECREF(item);
45057 }
45058 }
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 (arg1)->Append((wxArrayString const &)*arg2);
45062 wxPyEndAllowThreads(__tstate);
45063 if (PyErr_Occurred()) SWIG_fail;
45064 }
45065 resultobj = SWIG_Py_Void();
45066 {
45067 if (temp2) delete arg2;
45068 }
45069 return resultobj;
45070 fail:
45071 {
45072 if (temp2) delete arg2;
45073 }
45074 return NULL;
45075 }
45076
45077
45078 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45079 PyObject *resultobj = 0;
45080 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45081 wxString *arg2 = 0 ;
45082 unsigned int arg3 ;
45083 PyObject *arg4 = (PyObject *) NULL ;
45084 int result;
45085 void *argp1 = 0 ;
45086 int res1 = 0 ;
45087 bool temp2 = false ;
45088 unsigned int val3 ;
45089 int ecode3 = 0 ;
45090 PyObject * obj0 = 0 ;
45091 PyObject * obj1 = 0 ;
45092 PyObject * obj2 = 0 ;
45093 PyObject * obj3 = 0 ;
45094 char * kwnames[] = {
45095 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45096 };
45097
45098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45100 if (!SWIG_IsOK(res1)) {
45101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45102 }
45103 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45104 {
45105 arg2 = wxString_in_helper(obj1);
45106 if (arg2 == NULL) SWIG_fail;
45107 temp2 = true;
45108 }
45109 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45110 if (!SWIG_IsOK(ecode3)) {
45111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45112 }
45113 arg3 = static_cast< unsigned int >(val3);
45114 if (obj3) {
45115 arg4 = obj3;
45116 }
45117 {
45118 PyThreadState* __tstate = wxPyBeginAllowThreads();
45119 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45120 wxPyEndAllowThreads(__tstate);
45121 if (PyErr_Occurred()) SWIG_fail;
45122 }
45123 resultobj = SWIG_From_int(static_cast< int >(result));
45124 {
45125 if (temp2)
45126 delete arg2;
45127 }
45128 return resultobj;
45129 fail:
45130 {
45131 if (temp2)
45132 delete arg2;
45133 }
45134 return NULL;
45135 }
45136
45137
45138 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45139 PyObject *resultobj = 0;
45140 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45141 void *argp1 = 0 ;
45142 int res1 = 0 ;
45143 PyObject *swig_obj[1] ;
45144
45145 if (!args) SWIG_fail;
45146 swig_obj[0] = args;
45147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45148 if (!SWIG_IsOK(res1)) {
45149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45150 }
45151 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45152 {
45153 PyThreadState* __tstate = wxPyBeginAllowThreads();
45154 (arg1)->Clear();
45155 wxPyEndAllowThreads(__tstate);
45156 if (PyErr_Occurred()) SWIG_fail;
45157 }
45158 resultobj = SWIG_Py_Void();
45159 return resultobj;
45160 fail:
45161 return NULL;
45162 }
45163
45164
45165 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45166 PyObject *resultobj = 0;
45167 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45168 unsigned int arg2 ;
45169 void *argp1 = 0 ;
45170 int res1 = 0 ;
45171 unsigned int val2 ;
45172 int ecode2 = 0 ;
45173 PyObject * obj0 = 0 ;
45174 PyObject * obj1 = 0 ;
45175 char * kwnames[] = {
45176 (char *) "self",(char *) "n", NULL
45177 };
45178
45179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45181 if (!SWIG_IsOK(res1)) {
45182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45183 }
45184 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45185 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45186 if (!SWIG_IsOK(ecode2)) {
45187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45188 }
45189 arg2 = static_cast< unsigned int >(val2);
45190 {
45191 PyThreadState* __tstate = wxPyBeginAllowThreads();
45192 (arg1)->Delete(arg2);
45193 wxPyEndAllowThreads(__tstate);
45194 if (PyErr_Occurred()) SWIG_fail;
45195 }
45196 resultobj = SWIG_Py_Void();
45197 return resultobj;
45198 fail:
45199 return NULL;
45200 }
45201
45202
45203 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45204 PyObject *resultobj = 0;
45205 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45206 unsigned int arg2 ;
45207 PyObject *result = 0 ;
45208 void *argp1 = 0 ;
45209 int res1 = 0 ;
45210 unsigned int val2 ;
45211 int ecode2 = 0 ;
45212 PyObject * obj0 = 0 ;
45213 PyObject * obj1 = 0 ;
45214 char * kwnames[] = {
45215 (char *) "self",(char *) "n", NULL
45216 };
45217
45218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45220 if (!SWIG_IsOK(res1)) {
45221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45222 }
45223 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45224 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45225 if (!SWIG_IsOK(ecode2)) {
45226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45227 }
45228 arg2 = static_cast< unsigned int >(val2);
45229 {
45230 PyThreadState* __tstate = wxPyBeginAllowThreads();
45231 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45232 wxPyEndAllowThreads(__tstate);
45233 if (PyErr_Occurred()) SWIG_fail;
45234 }
45235 resultobj = result;
45236 return resultobj;
45237 fail:
45238 return NULL;
45239 }
45240
45241
45242 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45243 PyObject *resultobj = 0;
45244 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45245 unsigned int arg2 ;
45246 PyObject *arg3 = (PyObject *) 0 ;
45247 void *argp1 = 0 ;
45248 int res1 = 0 ;
45249 unsigned int val2 ;
45250 int ecode2 = 0 ;
45251 PyObject * obj0 = 0 ;
45252 PyObject * obj1 = 0 ;
45253 PyObject * obj2 = 0 ;
45254 char * kwnames[] = {
45255 (char *) "self",(char *) "n",(char *) "clientData", NULL
45256 };
45257
45258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45260 if (!SWIG_IsOK(res1)) {
45261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45262 }
45263 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45264 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45265 if (!SWIG_IsOK(ecode2)) {
45266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45267 }
45268 arg2 = static_cast< unsigned int >(val2);
45269 arg3 = obj2;
45270 {
45271 PyThreadState* __tstate = wxPyBeginAllowThreads();
45272 wxItemContainer_SetClientData(arg1,arg2,arg3);
45273 wxPyEndAllowThreads(__tstate);
45274 if (PyErr_Occurred()) SWIG_fail;
45275 }
45276 resultobj = SWIG_Py_Void();
45277 return resultobj;
45278 fail:
45279 return NULL;
45280 }
45281
45282
45283 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45284 PyObject *resultobj = 0;
45285 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45286 unsigned int result;
45287 void *argp1 = 0 ;
45288 int res1 = 0 ;
45289 PyObject *swig_obj[1] ;
45290
45291 if (!args) SWIG_fail;
45292 swig_obj[0] = args;
45293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45294 if (!SWIG_IsOK(res1)) {
45295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45296 }
45297 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45298 {
45299 PyThreadState* __tstate = wxPyBeginAllowThreads();
45300 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45301 wxPyEndAllowThreads(__tstate);
45302 if (PyErr_Occurred()) SWIG_fail;
45303 }
45304 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45305 return resultobj;
45306 fail:
45307 return NULL;
45308 }
45309
45310
45311 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45312 PyObject *resultobj = 0;
45313 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45314 bool result;
45315 void *argp1 = 0 ;
45316 int res1 = 0 ;
45317 PyObject *swig_obj[1] ;
45318
45319 if (!args) SWIG_fail;
45320 swig_obj[0] = args;
45321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45322 if (!SWIG_IsOK(res1)) {
45323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45324 }
45325 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45326 {
45327 PyThreadState* __tstate = wxPyBeginAllowThreads();
45328 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45329 wxPyEndAllowThreads(__tstate);
45330 if (PyErr_Occurred()) SWIG_fail;
45331 }
45332 {
45333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45334 }
45335 return resultobj;
45336 fail:
45337 return NULL;
45338 }
45339
45340
45341 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45342 PyObject *resultobj = 0;
45343 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45344 unsigned int arg2 ;
45345 wxString result;
45346 void *argp1 = 0 ;
45347 int res1 = 0 ;
45348 unsigned int val2 ;
45349 int ecode2 = 0 ;
45350 PyObject * obj0 = 0 ;
45351 PyObject * obj1 = 0 ;
45352 char * kwnames[] = {
45353 (char *) "self",(char *) "n", NULL
45354 };
45355
45356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45358 if (!SWIG_IsOK(res1)) {
45359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45360 }
45361 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45362 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45363 if (!SWIG_IsOK(ecode2)) {
45364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45365 }
45366 arg2 = static_cast< unsigned int >(val2);
45367 {
45368 PyThreadState* __tstate = wxPyBeginAllowThreads();
45369 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45370 wxPyEndAllowThreads(__tstate);
45371 if (PyErr_Occurred()) SWIG_fail;
45372 }
45373 {
45374 #if wxUSE_UNICODE
45375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45376 #else
45377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45378 #endif
45379 }
45380 return resultobj;
45381 fail:
45382 return NULL;
45383 }
45384
45385
45386 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45387 PyObject *resultobj = 0;
45388 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45389 wxArrayString result;
45390 void *argp1 = 0 ;
45391 int res1 = 0 ;
45392 PyObject *swig_obj[1] ;
45393
45394 if (!args) SWIG_fail;
45395 swig_obj[0] = args;
45396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45397 if (!SWIG_IsOK(res1)) {
45398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45399 }
45400 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45401 {
45402 PyThreadState* __tstate = wxPyBeginAllowThreads();
45403 result = ((wxItemContainer const *)arg1)->GetStrings();
45404 wxPyEndAllowThreads(__tstate);
45405 if (PyErr_Occurred()) SWIG_fail;
45406 }
45407 {
45408 resultobj = wxArrayString2PyList_helper(result);
45409 }
45410 return resultobj;
45411 fail:
45412 return NULL;
45413 }
45414
45415
45416 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45417 PyObject *resultobj = 0;
45418 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45419 unsigned int arg2 ;
45420 wxString *arg3 = 0 ;
45421 void *argp1 = 0 ;
45422 int res1 = 0 ;
45423 unsigned int val2 ;
45424 int ecode2 = 0 ;
45425 bool temp3 = false ;
45426 PyObject * obj0 = 0 ;
45427 PyObject * obj1 = 0 ;
45428 PyObject * obj2 = 0 ;
45429 char * kwnames[] = {
45430 (char *) "self",(char *) "n",(char *) "s", NULL
45431 };
45432
45433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45435 if (!SWIG_IsOK(res1)) {
45436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45437 }
45438 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45439 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45440 if (!SWIG_IsOK(ecode2)) {
45441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45442 }
45443 arg2 = static_cast< unsigned int >(val2);
45444 {
45445 arg3 = wxString_in_helper(obj2);
45446 if (arg3 == NULL) SWIG_fail;
45447 temp3 = true;
45448 }
45449 {
45450 PyThreadState* __tstate = wxPyBeginAllowThreads();
45451 (arg1)->SetString(arg2,(wxString const &)*arg3);
45452 wxPyEndAllowThreads(__tstate);
45453 if (PyErr_Occurred()) SWIG_fail;
45454 }
45455 resultobj = SWIG_Py_Void();
45456 {
45457 if (temp3)
45458 delete arg3;
45459 }
45460 return resultobj;
45461 fail:
45462 {
45463 if (temp3)
45464 delete arg3;
45465 }
45466 return NULL;
45467 }
45468
45469
45470 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45471 PyObject *resultobj = 0;
45472 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45473 wxString *arg2 = 0 ;
45474 int result;
45475 void *argp1 = 0 ;
45476 int res1 = 0 ;
45477 bool temp2 = false ;
45478 PyObject * obj0 = 0 ;
45479 PyObject * obj1 = 0 ;
45480 char * kwnames[] = {
45481 (char *) "self",(char *) "s", NULL
45482 };
45483
45484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45486 if (!SWIG_IsOK(res1)) {
45487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45488 }
45489 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45490 {
45491 arg2 = wxString_in_helper(obj1);
45492 if (arg2 == NULL) SWIG_fail;
45493 temp2 = true;
45494 }
45495 {
45496 PyThreadState* __tstate = wxPyBeginAllowThreads();
45497 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45498 wxPyEndAllowThreads(__tstate);
45499 if (PyErr_Occurred()) SWIG_fail;
45500 }
45501 resultobj = SWIG_From_int(static_cast< int >(result));
45502 {
45503 if (temp2)
45504 delete arg2;
45505 }
45506 return resultobj;
45507 fail:
45508 {
45509 if (temp2)
45510 delete arg2;
45511 }
45512 return NULL;
45513 }
45514
45515
45516 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45517 PyObject *resultobj = 0;
45518 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45519 int arg2 ;
45520 void *argp1 = 0 ;
45521 int res1 = 0 ;
45522 int val2 ;
45523 int ecode2 = 0 ;
45524 PyObject * obj0 = 0 ;
45525 PyObject * obj1 = 0 ;
45526 char * kwnames[] = {
45527 (char *) "self",(char *) "n", NULL
45528 };
45529
45530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45532 if (!SWIG_IsOK(res1)) {
45533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45534 }
45535 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45536 ecode2 = SWIG_AsVal_int(obj1, &val2);
45537 if (!SWIG_IsOK(ecode2)) {
45538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45539 }
45540 arg2 = static_cast< int >(val2);
45541 {
45542 PyThreadState* __tstate = wxPyBeginAllowThreads();
45543 (arg1)->SetSelection(arg2);
45544 wxPyEndAllowThreads(__tstate);
45545 if (PyErr_Occurred()) SWIG_fail;
45546 }
45547 resultobj = SWIG_Py_Void();
45548 return resultobj;
45549 fail:
45550 return NULL;
45551 }
45552
45553
45554 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45555 PyObject *resultobj = 0;
45556 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45557 int result;
45558 void *argp1 = 0 ;
45559 int res1 = 0 ;
45560 PyObject *swig_obj[1] ;
45561
45562 if (!args) SWIG_fail;
45563 swig_obj[0] = args;
45564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45565 if (!SWIG_IsOK(res1)) {
45566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45567 }
45568 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45569 {
45570 PyThreadState* __tstate = wxPyBeginAllowThreads();
45571 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45572 wxPyEndAllowThreads(__tstate);
45573 if (PyErr_Occurred()) SWIG_fail;
45574 }
45575 resultobj = SWIG_From_int(static_cast< int >(result));
45576 return resultobj;
45577 fail:
45578 return NULL;
45579 }
45580
45581
45582 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45583 PyObject *resultobj = 0;
45584 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45585 wxString *arg2 = 0 ;
45586 bool result;
45587 void *argp1 = 0 ;
45588 int res1 = 0 ;
45589 bool temp2 = false ;
45590 PyObject * obj0 = 0 ;
45591 PyObject * obj1 = 0 ;
45592 char * kwnames[] = {
45593 (char *) "self",(char *) "s", NULL
45594 };
45595
45596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45598 if (!SWIG_IsOK(res1)) {
45599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45600 }
45601 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45602 {
45603 arg2 = wxString_in_helper(obj1);
45604 if (arg2 == NULL) SWIG_fail;
45605 temp2 = true;
45606 }
45607 {
45608 PyThreadState* __tstate = wxPyBeginAllowThreads();
45609 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45610 wxPyEndAllowThreads(__tstate);
45611 if (PyErr_Occurred()) SWIG_fail;
45612 }
45613 {
45614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45615 }
45616 {
45617 if (temp2)
45618 delete arg2;
45619 }
45620 return resultobj;
45621 fail:
45622 {
45623 if (temp2)
45624 delete arg2;
45625 }
45626 return NULL;
45627 }
45628
45629
45630 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45631 PyObject *resultobj = 0;
45632 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45633 wxString result;
45634 void *argp1 = 0 ;
45635 int res1 = 0 ;
45636 PyObject *swig_obj[1] ;
45637
45638 if (!args) SWIG_fail;
45639 swig_obj[0] = args;
45640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45641 if (!SWIG_IsOK(res1)) {
45642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45643 }
45644 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45645 {
45646 PyThreadState* __tstate = wxPyBeginAllowThreads();
45647 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45648 wxPyEndAllowThreads(__tstate);
45649 if (PyErr_Occurred()) SWIG_fail;
45650 }
45651 {
45652 #if wxUSE_UNICODE
45653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45654 #else
45655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45656 #endif
45657 }
45658 return resultobj;
45659 fail:
45660 return NULL;
45661 }
45662
45663
45664 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45665 PyObject *resultobj = 0;
45666 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45667 int arg2 ;
45668 void *argp1 = 0 ;
45669 int res1 = 0 ;
45670 int val2 ;
45671 int ecode2 = 0 ;
45672 PyObject * obj0 = 0 ;
45673 PyObject * obj1 = 0 ;
45674 char * kwnames[] = {
45675 (char *) "self",(char *) "n", NULL
45676 };
45677
45678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45680 if (!SWIG_IsOK(res1)) {
45681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45682 }
45683 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45684 ecode2 = SWIG_AsVal_int(obj1, &val2);
45685 if (!SWIG_IsOK(ecode2)) {
45686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45687 }
45688 arg2 = static_cast< int >(val2);
45689 {
45690 PyThreadState* __tstate = wxPyBeginAllowThreads();
45691 (arg1)->Select(arg2);
45692 wxPyEndAllowThreads(__tstate);
45693 if (PyErr_Occurred()) SWIG_fail;
45694 }
45695 resultobj = SWIG_Py_Void();
45696 return resultobj;
45697 fail:
45698 return NULL;
45699 }
45700
45701
45702 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45703 PyObject *obj;
45704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45705 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45706 return SWIG_Py_Void();
45707 }
45708
45709 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45710 PyObject *obj;
45711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45712 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45713 return SWIG_Py_Void();
45714 }
45715
45716 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45717 PyObject *resultobj = 0;
45718 wxSizerItem *result = 0 ;
45719
45720 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45721 {
45722 PyThreadState* __tstate = wxPyBeginAllowThreads();
45723 result = (wxSizerItem *)new wxSizerItem();
45724 wxPyEndAllowThreads(__tstate);
45725 if (PyErr_Occurred()) SWIG_fail;
45726 }
45727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45728 return resultobj;
45729 fail:
45730 return NULL;
45731 }
45732
45733
45734 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45735 PyObject *resultobj = 0;
45736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45737 void *argp1 = 0 ;
45738 int res1 = 0 ;
45739 PyObject *swig_obj[1] ;
45740
45741 if (!args) SWIG_fail;
45742 swig_obj[0] = args;
45743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45744 if (!SWIG_IsOK(res1)) {
45745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45746 }
45747 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45748 {
45749 PyThreadState* __tstate = wxPyBeginAllowThreads();
45750 delete arg1;
45751
45752 wxPyEndAllowThreads(__tstate);
45753 if (PyErr_Occurred()) SWIG_fail;
45754 }
45755 resultobj = SWIG_Py_Void();
45756 return resultobj;
45757 fail:
45758 return NULL;
45759 }
45760
45761
45762 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45763 PyObject *resultobj = 0;
45764 wxWindow *arg1 = (wxWindow *) 0 ;
45765 int arg2 ;
45766 int arg3 ;
45767 int arg4 ;
45768 PyObject *arg5 = (PyObject *) NULL ;
45769 wxSizerItem *result = 0 ;
45770 void *argp1 = 0 ;
45771 int res1 = 0 ;
45772 int val2 ;
45773 int ecode2 = 0 ;
45774 int val3 ;
45775 int ecode3 = 0 ;
45776 int val4 ;
45777 int ecode4 = 0 ;
45778 PyObject * obj0 = 0 ;
45779 PyObject * obj1 = 0 ;
45780 PyObject * obj2 = 0 ;
45781 PyObject * obj3 = 0 ;
45782 PyObject * obj4 = 0 ;
45783 char * kwnames[] = {
45784 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45785 };
45786
45787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45789 if (!SWIG_IsOK(res1)) {
45790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45791 }
45792 arg1 = reinterpret_cast< wxWindow * >(argp1);
45793 ecode2 = SWIG_AsVal_int(obj1, &val2);
45794 if (!SWIG_IsOK(ecode2)) {
45795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45796 }
45797 arg2 = static_cast< int >(val2);
45798 ecode3 = SWIG_AsVal_int(obj2, &val3);
45799 if (!SWIG_IsOK(ecode3)) {
45800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45801 }
45802 arg3 = static_cast< int >(val3);
45803 ecode4 = SWIG_AsVal_int(obj3, &val4);
45804 if (!SWIG_IsOK(ecode4)) {
45805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45806 }
45807 arg4 = static_cast< int >(val4);
45808 if (obj4) {
45809 arg5 = obj4;
45810 }
45811 {
45812 PyThreadState* __tstate = wxPyBeginAllowThreads();
45813 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45814 wxPyEndAllowThreads(__tstate);
45815 if (PyErr_Occurred()) SWIG_fail;
45816 }
45817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45818 return resultobj;
45819 fail:
45820 return NULL;
45821 }
45822
45823
45824 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45825 PyObject *resultobj = 0;
45826 int arg1 ;
45827 int arg2 ;
45828 int arg3 ;
45829 int arg4 ;
45830 int arg5 ;
45831 PyObject *arg6 = (PyObject *) NULL ;
45832 wxSizerItem *result = 0 ;
45833 int val1 ;
45834 int ecode1 = 0 ;
45835 int val2 ;
45836 int ecode2 = 0 ;
45837 int val3 ;
45838 int ecode3 = 0 ;
45839 int val4 ;
45840 int ecode4 = 0 ;
45841 int val5 ;
45842 int ecode5 = 0 ;
45843 PyObject * obj0 = 0 ;
45844 PyObject * obj1 = 0 ;
45845 PyObject * obj2 = 0 ;
45846 PyObject * obj3 = 0 ;
45847 PyObject * obj4 = 0 ;
45848 PyObject * obj5 = 0 ;
45849 char * kwnames[] = {
45850 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45851 };
45852
45853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45854 ecode1 = SWIG_AsVal_int(obj0, &val1);
45855 if (!SWIG_IsOK(ecode1)) {
45856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45857 }
45858 arg1 = static_cast< int >(val1);
45859 ecode2 = SWIG_AsVal_int(obj1, &val2);
45860 if (!SWIG_IsOK(ecode2)) {
45861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45862 }
45863 arg2 = static_cast< int >(val2);
45864 ecode3 = SWIG_AsVal_int(obj2, &val3);
45865 if (!SWIG_IsOK(ecode3)) {
45866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45867 }
45868 arg3 = static_cast< int >(val3);
45869 ecode4 = SWIG_AsVal_int(obj3, &val4);
45870 if (!SWIG_IsOK(ecode4)) {
45871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45872 }
45873 arg4 = static_cast< int >(val4);
45874 ecode5 = SWIG_AsVal_int(obj4, &val5);
45875 if (!SWIG_IsOK(ecode5)) {
45876 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45877 }
45878 arg5 = static_cast< int >(val5);
45879 if (obj5) {
45880 arg6 = obj5;
45881 }
45882 {
45883 PyThreadState* __tstate = wxPyBeginAllowThreads();
45884 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45885 wxPyEndAllowThreads(__tstate);
45886 if (PyErr_Occurred()) SWIG_fail;
45887 }
45888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45889 return resultobj;
45890 fail:
45891 return NULL;
45892 }
45893
45894
45895 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45896 PyObject *resultobj = 0;
45897 wxSizer *arg1 = (wxSizer *) 0 ;
45898 int arg2 ;
45899 int arg3 ;
45900 int arg4 ;
45901 PyObject *arg5 = (PyObject *) NULL ;
45902 wxSizerItem *result = 0 ;
45903 int res1 = 0 ;
45904 int val2 ;
45905 int ecode2 = 0 ;
45906 int val3 ;
45907 int ecode3 = 0 ;
45908 int val4 ;
45909 int ecode4 = 0 ;
45910 PyObject * obj0 = 0 ;
45911 PyObject * obj1 = 0 ;
45912 PyObject * obj2 = 0 ;
45913 PyObject * obj3 = 0 ;
45914 PyObject * obj4 = 0 ;
45915 char * kwnames[] = {
45916 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45917 };
45918
45919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45920 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45921 if (!SWIG_IsOK(res1)) {
45922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45923 }
45924 ecode2 = SWIG_AsVal_int(obj1, &val2);
45925 if (!SWIG_IsOK(ecode2)) {
45926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45927 }
45928 arg2 = static_cast< int >(val2);
45929 ecode3 = SWIG_AsVal_int(obj2, &val3);
45930 if (!SWIG_IsOK(ecode3)) {
45931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45932 }
45933 arg3 = static_cast< int >(val3);
45934 ecode4 = SWIG_AsVal_int(obj3, &val4);
45935 if (!SWIG_IsOK(ecode4)) {
45936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45937 }
45938 arg4 = static_cast< int >(val4);
45939 if (obj4) {
45940 arg5 = obj4;
45941 }
45942 {
45943 PyThreadState* __tstate = wxPyBeginAllowThreads();
45944 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45945 wxPyEndAllowThreads(__tstate);
45946 if (PyErr_Occurred()) SWIG_fail;
45947 }
45948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45949 return resultobj;
45950 fail:
45951 return NULL;
45952 }
45953
45954
45955 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45956 PyObject *resultobj = 0;
45957 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45958 void *argp1 = 0 ;
45959 int res1 = 0 ;
45960 PyObject *swig_obj[1] ;
45961
45962 if (!args) SWIG_fail;
45963 swig_obj[0] = args;
45964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45965 if (!SWIG_IsOK(res1)) {
45966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45967 }
45968 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45969 {
45970 PyThreadState* __tstate = wxPyBeginAllowThreads();
45971 (arg1)->DeleteWindows();
45972 wxPyEndAllowThreads(__tstate);
45973 if (PyErr_Occurred()) SWIG_fail;
45974 }
45975 resultobj = SWIG_Py_Void();
45976 return resultobj;
45977 fail:
45978 return NULL;
45979 }
45980
45981
45982 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45983 PyObject *resultobj = 0;
45984 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45985 void *argp1 = 0 ;
45986 int res1 = 0 ;
45987 PyObject *swig_obj[1] ;
45988
45989 if (!args) SWIG_fail;
45990 swig_obj[0] = args;
45991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45992 if (!SWIG_IsOK(res1)) {
45993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45994 }
45995 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45996 {
45997 PyThreadState* __tstate = wxPyBeginAllowThreads();
45998 (arg1)->DetachSizer();
45999 wxPyEndAllowThreads(__tstate);
46000 if (PyErr_Occurred()) SWIG_fail;
46001 }
46002 resultobj = SWIG_Py_Void();
46003 return resultobj;
46004 fail:
46005 return NULL;
46006 }
46007
46008
46009 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46010 PyObject *resultobj = 0;
46011 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46012 wxSize result;
46013 void *argp1 = 0 ;
46014 int res1 = 0 ;
46015 PyObject *swig_obj[1] ;
46016
46017 if (!args) SWIG_fail;
46018 swig_obj[0] = args;
46019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46020 if (!SWIG_IsOK(res1)) {
46021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46022 }
46023 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46024 {
46025 PyThreadState* __tstate = wxPyBeginAllowThreads();
46026 result = (arg1)->GetSize();
46027 wxPyEndAllowThreads(__tstate);
46028 if (PyErr_Occurred()) SWIG_fail;
46029 }
46030 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46031 return resultobj;
46032 fail:
46033 return NULL;
46034 }
46035
46036
46037 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46038 PyObject *resultobj = 0;
46039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46040 wxSize result;
46041 void *argp1 = 0 ;
46042 int res1 = 0 ;
46043 PyObject *swig_obj[1] ;
46044
46045 if (!args) SWIG_fail;
46046 swig_obj[0] = args;
46047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46048 if (!SWIG_IsOK(res1)) {
46049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46050 }
46051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46052 {
46053 PyThreadState* __tstate = wxPyBeginAllowThreads();
46054 result = (arg1)->CalcMin();
46055 wxPyEndAllowThreads(__tstate);
46056 if (PyErr_Occurred()) SWIG_fail;
46057 }
46058 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46059 return resultobj;
46060 fail:
46061 return NULL;
46062 }
46063
46064
46065 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46066 PyObject *resultobj = 0;
46067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46068 wxPoint *arg2 = 0 ;
46069 wxSize *arg3 = 0 ;
46070 void *argp1 = 0 ;
46071 int res1 = 0 ;
46072 wxPoint temp2 ;
46073 wxSize temp3 ;
46074 PyObject * obj0 = 0 ;
46075 PyObject * obj1 = 0 ;
46076 PyObject * obj2 = 0 ;
46077 char * kwnames[] = {
46078 (char *) "self",(char *) "pos",(char *) "size", NULL
46079 };
46080
46081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46083 if (!SWIG_IsOK(res1)) {
46084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46085 }
46086 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46087 {
46088 arg2 = &temp2;
46089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46090 }
46091 {
46092 arg3 = &temp3;
46093 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46094 }
46095 {
46096 PyThreadState* __tstate = wxPyBeginAllowThreads();
46097 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46098 wxPyEndAllowThreads(__tstate);
46099 if (PyErr_Occurred()) SWIG_fail;
46100 }
46101 resultobj = SWIG_Py_Void();
46102 return resultobj;
46103 fail:
46104 return NULL;
46105 }
46106
46107
46108 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46109 PyObject *resultobj = 0;
46110 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46111 wxSize result;
46112 void *argp1 = 0 ;
46113 int res1 = 0 ;
46114 PyObject *swig_obj[1] ;
46115
46116 if (!args) SWIG_fail;
46117 swig_obj[0] = args;
46118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46119 if (!SWIG_IsOK(res1)) {
46120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46121 }
46122 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46123 {
46124 PyThreadState* __tstate = wxPyBeginAllowThreads();
46125 result = (arg1)->GetMinSize();
46126 wxPyEndAllowThreads(__tstate);
46127 if (PyErr_Occurred()) SWIG_fail;
46128 }
46129 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46130 return resultobj;
46131 fail:
46132 return NULL;
46133 }
46134
46135
46136 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46137 PyObject *resultobj = 0;
46138 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46139 wxSize result;
46140 void *argp1 = 0 ;
46141 int res1 = 0 ;
46142 PyObject *swig_obj[1] ;
46143
46144 if (!args) SWIG_fail;
46145 swig_obj[0] = args;
46146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46147 if (!SWIG_IsOK(res1)) {
46148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46149 }
46150 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46151 {
46152 PyThreadState* __tstate = wxPyBeginAllowThreads();
46153 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46154 wxPyEndAllowThreads(__tstate);
46155 if (PyErr_Occurred()) SWIG_fail;
46156 }
46157 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46158 return resultobj;
46159 fail:
46160 return NULL;
46161 }
46162
46163
46164 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46165 PyObject *resultobj = 0;
46166 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46167 int arg2 ;
46168 int arg3 ;
46169 void *argp1 = 0 ;
46170 int res1 = 0 ;
46171 int val2 ;
46172 int ecode2 = 0 ;
46173 int val3 ;
46174 int ecode3 = 0 ;
46175 PyObject * obj0 = 0 ;
46176 PyObject * obj1 = 0 ;
46177 PyObject * obj2 = 0 ;
46178 char * kwnames[] = {
46179 (char *) "self",(char *) "x",(char *) "y", NULL
46180 };
46181
46182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46184 if (!SWIG_IsOK(res1)) {
46185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46186 }
46187 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46188 ecode2 = SWIG_AsVal_int(obj1, &val2);
46189 if (!SWIG_IsOK(ecode2)) {
46190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46191 }
46192 arg2 = static_cast< int >(val2);
46193 ecode3 = SWIG_AsVal_int(obj2, &val3);
46194 if (!SWIG_IsOK(ecode3)) {
46195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46196 }
46197 arg3 = static_cast< int >(val3);
46198 {
46199 PyThreadState* __tstate = wxPyBeginAllowThreads();
46200 (arg1)->SetInitSize(arg2,arg3);
46201 wxPyEndAllowThreads(__tstate);
46202 if (PyErr_Occurred()) SWIG_fail;
46203 }
46204 resultobj = SWIG_Py_Void();
46205 return resultobj;
46206 fail:
46207 return NULL;
46208 }
46209
46210
46211 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46212 PyObject *resultobj = 0;
46213 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46214 int arg2 ;
46215 int arg3 ;
46216 void *argp1 = 0 ;
46217 int res1 = 0 ;
46218 int val2 ;
46219 int ecode2 = 0 ;
46220 int val3 ;
46221 int ecode3 = 0 ;
46222 PyObject * obj0 = 0 ;
46223 PyObject * obj1 = 0 ;
46224 PyObject * obj2 = 0 ;
46225 char * kwnames[] = {
46226 (char *) "self",(char *) "width",(char *) "height", NULL
46227 };
46228
46229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46231 if (!SWIG_IsOK(res1)) {
46232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46233 }
46234 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46235 ecode2 = SWIG_AsVal_int(obj1, &val2);
46236 if (!SWIG_IsOK(ecode2)) {
46237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46238 }
46239 arg2 = static_cast< int >(val2);
46240 ecode3 = SWIG_AsVal_int(obj2, &val3);
46241 if (!SWIG_IsOK(ecode3)) {
46242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46243 }
46244 arg3 = static_cast< int >(val3);
46245 {
46246 PyThreadState* __tstate = wxPyBeginAllowThreads();
46247 (arg1)->SetRatio(arg2,arg3);
46248 wxPyEndAllowThreads(__tstate);
46249 if (PyErr_Occurred()) SWIG_fail;
46250 }
46251 resultobj = SWIG_Py_Void();
46252 return resultobj;
46253 fail:
46254 return NULL;
46255 }
46256
46257
46258 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46259 PyObject *resultobj = 0;
46260 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46261 wxSize *arg2 = 0 ;
46262 void *argp1 = 0 ;
46263 int res1 = 0 ;
46264 wxSize temp2 ;
46265 PyObject * obj0 = 0 ;
46266 PyObject * obj1 = 0 ;
46267 char * kwnames[] = {
46268 (char *) "self",(char *) "size", NULL
46269 };
46270
46271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46273 if (!SWIG_IsOK(res1)) {
46274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46275 }
46276 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46277 {
46278 arg2 = &temp2;
46279 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46280 }
46281 {
46282 PyThreadState* __tstate = wxPyBeginAllowThreads();
46283 (arg1)->SetRatio((wxSize const &)*arg2);
46284 wxPyEndAllowThreads(__tstate);
46285 if (PyErr_Occurred()) SWIG_fail;
46286 }
46287 resultobj = SWIG_Py_Void();
46288 return resultobj;
46289 fail:
46290 return NULL;
46291 }
46292
46293
46294 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46295 PyObject *resultobj = 0;
46296 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46297 float arg2 ;
46298 void *argp1 = 0 ;
46299 int res1 = 0 ;
46300 float val2 ;
46301 int ecode2 = 0 ;
46302 PyObject * obj0 = 0 ;
46303 PyObject * obj1 = 0 ;
46304 char * kwnames[] = {
46305 (char *) "self",(char *) "ratio", NULL
46306 };
46307
46308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46310 if (!SWIG_IsOK(res1)) {
46311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46312 }
46313 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46314 ecode2 = SWIG_AsVal_float(obj1, &val2);
46315 if (!SWIG_IsOK(ecode2)) {
46316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46317 }
46318 arg2 = static_cast< float >(val2);
46319 {
46320 PyThreadState* __tstate = wxPyBeginAllowThreads();
46321 (arg1)->SetRatio(arg2);
46322 wxPyEndAllowThreads(__tstate);
46323 if (PyErr_Occurred()) SWIG_fail;
46324 }
46325 resultobj = SWIG_Py_Void();
46326 return resultobj;
46327 fail:
46328 return NULL;
46329 }
46330
46331
46332 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46333 PyObject *resultobj = 0;
46334 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46335 float result;
46336 void *argp1 = 0 ;
46337 int res1 = 0 ;
46338 PyObject *swig_obj[1] ;
46339
46340 if (!args) SWIG_fail;
46341 swig_obj[0] = args;
46342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46343 if (!SWIG_IsOK(res1)) {
46344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46345 }
46346 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46347 {
46348 PyThreadState* __tstate = wxPyBeginAllowThreads();
46349 result = (float)(arg1)->GetRatio();
46350 wxPyEndAllowThreads(__tstate);
46351 if (PyErr_Occurred()) SWIG_fail;
46352 }
46353 resultobj = SWIG_From_float(static_cast< float >(result));
46354 return resultobj;
46355 fail:
46356 return NULL;
46357 }
46358
46359
46360 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46361 PyObject *resultobj = 0;
46362 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46363 wxRect result;
46364 void *argp1 = 0 ;
46365 int res1 = 0 ;
46366 PyObject *swig_obj[1] ;
46367
46368 if (!args) SWIG_fail;
46369 swig_obj[0] = args;
46370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46371 if (!SWIG_IsOK(res1)) {
46372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46373 }
46374 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46375 {
46376 PyThreadState* __tstate = wxPyBeginAllowThreads();
46377 result = (arg1)->GetRect();
46378 wxPyEndAllowThreads(__tstate);
46379 if (PyErr_Occurred()) SWIG_fail;
46380 }
46381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46382 return resultobj;
46383 fail:
46384 return NULL;
46385 }
46386
46387
46388 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46389 PyObject *resultobj = 0;
46390 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46391 bool result;
46392 void *argp1 = 0 ;
46393 int res1 = 0 ;
46394 PyObject *swig_obj[1] ;
46395
46396 if (!args) SWIG_fail;
46397 swig_obj[0] = args;
46398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46399 if (!SWIG_IsOK(res1)) {
46400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46401 }
46402 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46403 {
46404 PyThreadState* __tstate = wxPyBeginAllowThreads();
46405 result = (bool)(arg1)->IsWindow();
46406 wxPyEndAllowThreads(__tstate);
46407 if (PyErr_Occurred()) SWIG_fail;
46408 }
46409 {
46410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46411 }
46412 return resultobj;
46413 fail:
46414 return NULL;
46415 }
46416
46417
46418 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46419 PyObject *resultobj = 0;
46420 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46421 bool result;
46422 void *argp1 = 0 ;
46423 int res1 = 0 ;
46424 PyObject *swig_obj[1] ;
46425
46426 if (!args) SWIG_fail;
46427 swig_obj[0] = args;
46428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46429 if (!SWIG_IsOK(res1)) {
46430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46431 }
46432 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46433 {
46434 PyThreadState* __tstate = wxPyBeginAllowThreads();
46435 result = (bool)(arg1)->IsSizer();
46436 wxPyEndAllowThreads(__tstate);
46437 if (PyErr_Occurred()) SWIG_fail;
46438 }
46439 {
46440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46441 }
46442 return resultobj;
46443 fail:
46444 return NULL;
46445 }
46446
46447
46448 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46449 PyObject *resultobj = 0;
46450 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46451 bool result;
46452 void *argp1 = 0 ;
46453 int res1 = 0 ;
46454 PyObject *swig_obj[1] ;
46455
46456 if (!args) SWIG_fail;
46457 swig_obj[0] = args;
46458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46459 if (!SWIG_IsOK(res1)) {
46460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46461 }
46462 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46463 {
46464 PyThreadState* __tstate = wxPyBeginAllowThreads();
46465 result = (bool)(arg1)->IsSpacer();
46466 wxPyEndAllowThreads(__tstate);
46467 if (PyErr_Occurred()) SWIG_fail;
46468 }
46469 {
46470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46471 }
46472 return resultobj;
46473 fail:
46474 return NULL;
46475 }
46476
46477
46478 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46479 PyObject *resultobj = 0;
46480 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46481 int arg2 ;
46482 void *argp1 = 0 ;
46483 int res1 = 0 ;
46484 int val2 ;
46485 int ecode2 = 0 ;
46486 PyObject * obj0 = 0 ;
46487 PyObject * obj1 = 0 ;
46488 char * kwnames[] = {
46489 (char *) "self",(char *) "proportion", NULL
46490 };
46491
46492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46494 if (!SWIG_IsOK(res1)) {
46495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46496 }
46497 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46498 ecode2 = SWIG_AsVal_int(obj1, &val2);
46499 if (!SWIG_IsOK(ecode2)) {
46500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46501 }
46502 arg2 = static_cast< int >(val2);
46503 {
46504 PyThreadState* __tstate = wxPyBeginAllowThreads();
46505 (arg1)->SetProportion(arg2);
46506 wxPyEndAllowThreads(__tstate);
46507 if (PyErr_Occurred()) SWIG_fail;
46508 }
46509 resultobj = SWIG_Py_Void();
46510 return resultobj;
46511 fail:
46512 return NULL;
46513 }
46514
46515
46516 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46517 PyObject *resultobj = 0;
46518 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46519 int result;
46520 void *argp1 = 0 ;
46521 int res1 = 0 ;
46522 PyObject *swig_obj[1] ;
46523
46524 if (!args) SWIG_fail;
46525 swig_obj[0] = args;
46526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46527 if (!SWIG_IsOK(res1)) {
46528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46529 }
46530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46531 {
46532 PyThreadState* __tstate = wxPyBeginAllowThreads();
46533 result = (int)(arg1)->GetProportion();
46534 wxPyEndAllowThreads(__tstate);
46535 if (PyErr_Occurred()) SWIG_fail;
46536 }
46537 resultobj = SWIG_From_int(static_cast< int >(result));
46538 return resultobj;
46539 fail:
46540 return NULL;
46541 }
46542
46543
46544 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46545 PyObject *resultobj = 0;
46546 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46547 int arg2 ;
46548 void *argp1 = 0 ;
46549 int res1 = 0 ;
46550 int val2 ;
46551 int ecode2 = 0 ;
46552 PyObject * obj0 = 0 ;
46553 PyObject * obj1 = 0 ;
46554 char * kwnames[] = {
46555 (char *) "self",(char *) "flag", NULL
46556 };
46557
46558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46560 if (!SWIG_IsOK(res1)) {
46561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46562 }
46563 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46564 ecode2 = SWIG_AsVal_int(obj1, &val2);
46565 if (!SWIG_IsOK(ecode2)) {
46566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46567 }
46568 arg2 = static_cast< int >(val2);
46569 {
46570 PyThreadState* __tstate = wxPyBeginAllowThreads();
46571 (arg1)->SetFlag(arg2);
46572 wxPyEndAllowThreads(__tstate);
46573 if (PyErr_Occurred()) SWIG_fail;
46574 }
46575 resultobj = SWIG_Py_Void();
46576 return resultobj;
46577 fail:
46578 return NULL;
46579 }
46580
46581
46582 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46583 PyObject *resultobj = 0;
46584 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46585 int result;
46586 void *argp1 = 0 ;
46587 int res1 = 0 ;
46588 PyObject *swig_obj[1] ;
46589
46590 if (!args) SWIG_fail;
46591 swig_obj[0] = args;
46592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46593 if (!SWIG_IsOK(res1)) {
46594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46595 }
46596 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46597 {
46598 PyThreadState* __tstate = wxPyBeginAllowThreads();
46599 result = (int)(arg1)->GetFlag();
46600 wxPyEndAllowThreads(__tstate);
46601 if (PyErr_Occurred()) SWIG_fail;
46602 }
46603 resultobj = SWIG_From_int(static_cast< int >(result));
46604 return resultobj;
46605 fail:
46606 return NULL;
46607 }
46608
46609
46610 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46611 PyObject *resultobj = 0;
46612 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46613 int arg2 ;
46614 void *argp1 = 0 ;
46615 int res1 = 0 ;
46616 int val2 ;
46617 int ecode2 = 0 ;
46618 PyObject * obj0 = 0 ;
46619 PyObject * obj1 = 0 ;
46620 char * kwnames[] = {
46621 (char *) "self",(char *) "border", NULL
46622 };
46623
46624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46626 if (!SWIG_IsOK(res1)) {
46627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46628 }
46629 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46630 ecode2 = SWIG_AsVal_int(obj1, &val2);
46631 if (!SWIG_IsOK(ecode2)) {
46632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46633 }
46634 arg2 = static_cast< int >(val2);
46635 {
46636 PyThreadState* __tstate = wxPyBeginAllowThreads();
46637 (arg1)->SetBorder(arg2);
46638 wxPyEndAllowThreads(__tstate);
46639 if (PyErr_Occurred()) SWIG_fail;
46640 }
46641 resultobj = SWIG_Py_Void();
46642 return resultobj;
46643 fail:
46644 return NULL;
46645 }
46646
46647
46648 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46649 PyObject *resultobj = 0;
46650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46651 int result;
46652 void *argp1 = 0 ;
46653 int res1 = 0 ;
46654 PyObject *swig_obj[1] ;
46655
46656 if (!args) SWIG_fail;
46657 swig_obj[0] = args;
46658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46659 if (!SWIG_IsOK(res1)) {
46660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46661 }
46662 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46663 {
46664 PyThreadState* __tstate = wxPyBeginAllowThreads();
46665 result = (int)(arg1)->GetBorder();
46666 wxPyEndAllowThreads(__tstate);
46667 if (PyErr_Occurred()) SWIG_fail;
46668 }
46669 resultobj = SWIG_From_int(static_cast< int >(result));
46670 return resultobj;
46671 fail:
46672 return NULL;
46673 }
46674
46675
46676 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46677 PyObject *resultobj = 0;
46678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46679 wxWindow *result = 0 ;
46680 void *argp1 = 0 ;
46681 int res1 = 0 ;
46682 PyObject *swig_obj[1] ;
46683
46684 if (!args) SWIG_fail;
46685 swig_obj[0] = args;
46686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46687 if (!SWIG_IsOK(res1)) {
46688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46689 }
46690 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46691 {
46692 PyThreadState* __tstate = wxPyBeginAllowThreads();
46693 result = (wxWindow *)(arg1)->GetWindow();
46694 wxPyEndAllowThreads(__tstate);
46695 if (PyErr_Occurred()) SWIG_fail;
46696 }
46697 {
46698 resultobj = wxPyMake_wxObject(result, 0);
46699 }
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46707 PyObject *resultobj = 0;
46708 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46709 wxWindow *arg2 = (wxWindow *) 0 ;
46710 void *argp1 = 0 ;
46711 int res1 = 0 ;
46712 void *argp2 = 0 ;
46713 int res2 = 0 ;
46714 PyObject * obj0 = 0 ;
46715 PyObject * obj1 = 0 ;
46716 char * kwnames[] = {
46717 (char *) "self",(char *) "window", NULL
46718 };
46719
46720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46722 if (!SWIG_IsOK(res1)) {
46723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46724 }
46725 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46727 if (!SWIG_IsOK(res2)) {
46728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46729 }
46730 arg2 = reinterpret_cast< wxWindow * >(argp2);
46731 {
46732 PyThreadState* __tstate = wxPyBeginAllowThreads();
46733 (arg1)->SetWindow(arg2);
46734 wxPyEndAllowThreads(__tstate);
46735 if (PyErr_Occurred()) SWIG_fail;
46736 }
46737 resultobj = SWIG_Py_Void();
46738 return resultobj;
46739 fail:
46740 return NULL;
46741 }
46742
46743
46744 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46745 PyObject *resultobj = 0;
46746 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46747 wxSizer *result = 0 ;
46748 void *argp1 = 0 ;
46749 int res1 = 0 ;
46750 PyObject *swig_obj[1] ;
46751
46752 if (!args) SWIG_fail;
46753 swig_obj[0] = args;
46754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46755 if (!SWIG_IsOK(res1)) {
46756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46757 }
46758 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46759 {
46760 PyThreadState* __tstate = wxPyBeginAllowThreads();
46761 result = (wxSizer *)(arg1)->GetSizer();
46762 wxPyEndAllowThreads(__tstate);
46763 if (PyErr_Occurred()) SWIG_fail;
46764 }
46765 {
46766 resultobj = wxPyMake_wxObject(result, (bool)0);
46767 }
46768 return resultobj;
46769 fail:
46770 return NULL;
46771 }
46772
46773
46774 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46775 PyObject *resultobj = 0;
46776 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46777 wxSizer *arg2 = (wxSizer *) 0 ;
46778 void *argp1 = 0 ;
46779 int res1 = 0 ;
46780 int res2 = 0 ;
46781 PyObject * obj0 = 0 ;
46782 PyObject * obj1 = 0 ;
46783 char * kwnames[] = {
46784 (char *) "self",(char *) "sizer", NULL
46785 };
46786
46787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46789 if (!SWIG_IsOK(res1)) {
46790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46791 }
46792 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46793 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46794 if (!SWIG_IsOK(res2)) {
46795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46796 }
46797 {
46798 PyThreadState* __tstate = wxPyBeginAllowThreads();
46799 (arg1)->SetSizer(arg2);
46800 wxPyEndAllowThreads(__tstate);
46801 if (PyErr_Occurred()) SWIG_fail;
46802 }
46803 resultobj = SWIG_Py_Void();
46804 return resultobj;
46805 fail:
46806 return NULL;
46807 }
46808
46809
46810 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46811 PyObject *resultobj = 0;
46812 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46813 wxSize *result = 0 ;
46814 void *argp1 = 0 ;
46815 int res1 = 0 ;
46816 PyObject *swig_obj[1] ;
46817
46818 if (!args) SWIG_fail;
46819 swig_obj[0] = args;
46820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46821 if (!SWIG_IsOK(res1)) {
46822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46823 }
46824 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46825 {
46826 PyThreadState* __tstate = wxPyBeginAllowThreads();
46827 {
46828 wxSize const &_result_ref = (arg1)->GetSpacer();
46829 result = (wxSize *) &_result_ref;
46830 }
46831 wxPyEndAllowThreads(__tstate);
46832 if (PyErr_Occurred()) SWIG_fail;
46833 }
46834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46835 return resultobj;
46836 fail:
46837 return NULL;
46838 }
46839
46840
46841 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46842 PyObject *resultobj = 0;
46843 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46844 wxSize *arg2 = 0 ;
46845 void *argp1 = 0 ;
46846 int res1 = 0 ;
46847 wxSize temp2 ;
46848 PyObject * obj0 = 0 ;
46849 PyObject * obj1 = 0 ;
46850 char * kwnames[] = {
46851 (char *) "self",(char *) "size", NULL
46852 };
46853
46854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46856 if (!SWIG_IsOK(res1)) {
46857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46858 }
46859 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46860 {
46861 arg2 = &temp2;
46862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46863 }
46864 {
46865 PyThreadState* __tstate = wxPyBeginAllowThreads();
46866 (arg1)->SetSpacer((wxSize const &)*arg2);
46867 wxPyEndAllowThreads(__tstate);
46868 if (PyErr_Occurred()) SWIG_fail;
46869 }
46870 resultobj = SWIG_Py_Void();
46871 return resultobj;
46872 fail:
46873 return NULL;
46874 }
46875
46876
46877 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46878 PyObject *resultobj = 0;
46879 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46880 bool arg2 ;
46881 void *argp1 = 0 ;
46882 int res1 = 0 ;
46883 bool val2 ;
46884 int ecode2 = 0 ;
46885 PyObject * obj0 = 0 ;
46886 PyObject * obj1 = 0 ;
46887 char * kwnames[] = {
46888 (char *) "self",(char *) "show", NULL
46889 };
46890
46891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46893 if (!SWIG_IsOK(res1)) {
46894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46895 }
46896 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46897 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46898 if (!SWIG_IsOK(ecode2)) {
46899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46900 }
46901 arg2 = static_cast< bool >(val2);
46902 {
46903 PyThreadState* __tstate = wxPyBeginAllowThreads();
46904 (arg1)->Show(arg2);
46905 wxPyEndAllowThreads(__tstate);
46906 if (PyErr_Occurred()) SWIG_fail;
46907 }
46908 resultobj = SWIG_Py_Void();
46909 return resultobj;
46910 fail:
46911 return NULL;
46912 }
46913
46914
46915 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46916 PyObject *resultobj = 0;
46917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46918 bool result;
46919 void *argp1 = 0 ;
46920 int res1 = 0 ;
46921 PyObject *swig_obj[1] ;
46922
46923 if (!args) SWIG_fail;
46924 swig_obj[0] = args;
46925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46926 if (!SWIG_IsOK(res1)) {
46927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46928 }
46929 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46930 {
46931 PyThreadState* __tstate = wxPyBeginAllowThreads();
46932 result = (bool)(arg1)->IsShown();
46933 wxPyEndAllowThreads(__tstate);
46934 if (PyErr_Occurred()) SWIG_fail;
46935 }
46936 {
46937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46938 }
46939 return resultobj;
46940 fail:
46941 return NULL;
46942 }
46943
46944
46945 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46946 PyObject *resultobj = 0;
46947 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46948 wxPoint result;
46949 void *argp1 = 0 ;
46950 int res1 = 0 ;
46951 PyObject *swig_obj[1] ;
46952
46953 if (!args) SWIG_fail;
46954 swig_obj[0] = args;
46955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46956 if (!SWIG_IsOK(res1)) {
46957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46958 }
46959 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46960 {
46961 PyThreadState* __tstate = wxPyBeginAllowThreads();
46962 result = (arg1)->GetPosition();
46963 wxPyEndAllowThreads(__tstate);
46964 if (PyErr_Occurred()) SWIG_fail;
46965 }
46966 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46967 return resultobj;
46968 fail:
46969 return NULL;
46970 }
46971
46972
46973 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46974 PyObject *resultobj = 0;
46975 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46976 PyObject *result = 0 ;
46977 void *argp1 = 0 ;
46978 int res1 = 0 ;
46979 PyObject *swig_obj[1] ;
46980
46981 if (!args) SWIG_fail;
46982 swig_obj[0] = args;
46983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46984 if (!SWIG_IsOK(res1)) {
46985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46986 }
46987 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46988 {
46989 PyThreadState* __tstate = wxPyBeginAllowThreads();
46990 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46991 wxPyEndAllowThreads(__tstate);
46992 if (PyErr_Occurred()) SWIG_fail;
46993 }
46994 resultobj = result;
46995 return resultobj;
46996 fail:
46997 return NULL;
46998 }
46999
47000
47001 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47002 PyObject *resultobj = 0;
47003 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47004 PyObject *arg2 = (PyObject *) 0 ;
47005 void *argp1 = 0 ;
47006 int res1 = 0 ;
47007 PyObject * obj0 = 0 ;
47008 PyObject * obj1 = 0 ;
47009 char * kwnames[] = {
47010 (char *) "self",(char *) "userData", NULL
47011 };
47012
47013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47015 if (!SWIG_IsOK(res1)) {
47016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47017 }
47018 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47019 arg2 = obj1;
47020 {
47021 PyThreadState* __tstate = wxPyBeginAllowThreads();
47022 wxSizerItem_SetUserData(arg1,arg2);
47023 wxPyEndAllowThreads(__tstate);
47024 if (PyErr_Occurred()) SWIG_fail;
47025 }
47026 resultobj = SWIG_Py_Void();
47027 return resultobj;
47028 fail:
47029 return NULL;
47030 }
47031
47032
47033 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47034 PyObject *obj;
47035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47036 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47037 return SWIG_Py_Void();
47038 }
47039
47040 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47041 return SWIG_Python_InitShadowInstance(args);
47042 }
47043
47044 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47045 PyObject *resultobj = 0;
47046 wxSizer *arg1 = (wxSizer *) 0 ;
47047 void *argp1 = 0 ;
47048 int res1 = 0 ;
47049 PyObject *swig_obj[1] ;
47050
47051 if (!args) SWIG_fail;
47052 swig_obj[0] = args;
47053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47054 if (!SWIG_IsOK(res1)) {
47055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47056 }
47057 arg1 = reinterpret_cast< wxSizer * >(argp1);
47058 {
47059 PyThreadState* __tstate = wxPyBeginAllowThreads();
47060 delete arg1;
47061
47062 wxPyEndAllowThreads(__tstate);
47063 if (PyErr_Occurred()) SWIG_fail;
47064 }
47065 resultobj = SWIG_Py_Void();
47066 return resultobj;
47067 fail:
47068 return NULL;
47069 }
47070
47071
47072 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47073 PyObject *resultobj = 0;
47074 wxSizer *arg1 = (wxSizer *) 0 ;
47075 PyObject *arg2 = (PyObject *) 0 ;
47076 void *argp1 = 0 ;
47077 int res1 = 0 ;
47078 PyObject * obj0 = 0 ;
47079 PyObject * obj1 = 0 ;
47080 char * kwnames[] = {
47081 (char *) "self",(char *) "_self", NULL
47082 };
47083
47084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47086 if (!SWIG_IsOK(res1)) {
47087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47088 }
47089 arg1 = reinterpret_cast< wxSizer * >(argp1);
47090 arg2 = obj1;
47091 {
47092 PyThreadState* __tstate = wxPyBeginAllowThreads();
47093 wxSizer__setOORInfo(arg1,arg2);
47094 wxPyEndAllowThreads(__tstate);
47095 if (PyErr_Occurred()) SWIG_fail;
47096 }
47097 resultobj = SWIG_Py_Void();
47098 return resultobj;
47099 fail:
47100 return NULL;
47101 }
47102
47103
47104 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47105 PyObject *resultobj = 0;
47106 wxSizer *arg1 = (wxSizer *) 0 ;
47107 PyObject *arg2 = (PyObject *) 0 ;
47108 int arg3 = (int) 0 ;
47109 int arg4 = (int) 0 ;
47110 int arg5 = (int) 0 ;
47111 PyObject *arg6 = (PyObject *) NULL ;
47112 wxSizerItem *result = 0 ;
47113 void *argp1 = 0 ;
47114 int res1 = 0 ;
47115 int val3 ;
47116 int ecode3 = 0 ;
47117 int val4 ;
47118 int ecode4 = 0 ;
47119 int val5 ;
47120 int ecode5 = 0 ;
47121 PyObject * obj0 = 0 ;
47122 PyObject * obj1 = 0 ;
47123 PyObject * obj2 = 0 ;
47124 PyObject * obj3 = 0 ;
47125 PyObject * obj4 = 0 ;
47126 PyObject * obj5 = 0 ;
47127 char * kwnames[] = {
47128 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47129 };
47130
47131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47133 if (!SWIG_IsOK(res1)) {
47134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47135 }
47136 arg1 = reinterpret_cast< wxSizer * >(argp1);
47137 arg2 = obj1;
47138 if (obj2) {
47139 ecode3 = SWIG_AsVal_int(obj2, &val3);
47140 if (!SWIG_IsOK(ecode3)) {
47141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47142 }
47143 arg3 = static_cast< int >(val3);
47144 }
47145 if (obj3) {
47146 ecode4 = SWIG_AsVal_int(obj3, &val4);
47147 if (!SWIG_IsOK(ecode4)) {
47148 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47149 }
47150 arg4 = static_cast< int >(val4);
47151 }
47152 if (obj4) {
47153 ecode5 = SWIG_AsVal_int(obj4, &val5);
47154 if (!SWIG_IsOK(ecode5)) {
47155 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47156 }
47157 arg5 = static_cast< int >(val5);
47158 }
47159 if (obj5) {
47160 arg6 = obj5;
47161 }
47162 {
47163 PyThreadState* __tstate = wxPyBeginAllowThreads();
47164 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47165 wxPyEndAllowThreads(__tstate);
47166 if (PyErr_Occurred()) SWIG_fail;
47167 }
47168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47169 return resultobj;
47170 fail:
47171 return NULL;
47172 }
47173
47174
47175 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47176 PyObject *resultobj = 0;
47177 wxSizer *arg1 = (wxSizer *) 0 ;
47178 int arg2 ;
47179 PyObject *arg3 = (PyObject *) 0 ;
47180 int arg4 = (int) 0 ;
47181 int arg5 = (int) 0 ;
47182 int arg6 = (int) 0 ;
47183 PyObject *arg7 = (PyObject *) NULL ;
47184 wxSizerItem *result = 0 ;
47185 void *argp1 = 0 ;
47186 int res1 = 0 ;
47187 int val2 ;
47188 int ecode2 = 0 ;
47189 int val4 ;
47190 int ecode4 = 0 ;
47191 int val5 ;
47192 int ecode5 = 0 ;
47193 int val6 ;
47194 int ecode6 = 0 ;
47195 PyObject * obj0 = 0 ;
47196 PyObject * obj1 = 0 ;
47197 PyObject * obj2 = 0 ;
47198 PyObject * obj3 = 0 ;
47199 PyObject * obj4 = 0 ;
47200 PyObject * obj5 = 0 ;
47201 PyObject * obj6 = 0 ;
47202 char * kwnames[] = {
47203 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47204 };
47205
47206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47208 if (!SWIG_IsOK(res1)) {
47209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47210 }
47211 arg1 = reinterpret_cast< wxSizer * >(argp1);
47212 ecode2 = SWIG_AsVal_int(obj1, &val2);
47213 if (!SWIG_IsOK(ecode2)) {
47214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47215 }
47216 arg2 = static_cast< int >(val2);
47217 arg3 = obj2;
47218 if (obj3) {
47219 ecode4 = SWIG_AsVal_int(obj3, &val4);
47220 if (!SWIG_IsOK(ecode4)) {
47221 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47222 }
47223 arg4 = static_cast< int >(val4);
47224 }
47225 if (obj4) {
47226 ecode5 = SWIG_AsVal_int(obj4, &val5);
47227 if (!SWIG_IsOK(ecode5)) {
47228 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47229 }
47230 arg5 = static_cast< int >(val5);
47231 }
47232 if (obj5) {
47233 ecode6 = SWIG_AsVal_int(obj5, &val6);
47234 if (!SWIG_IsOK(ecode6)) {
47235 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47236 }
47237 arg6 = static_cast< int >(val6);
47238 }
47239 if (obj6) {
47240 arg7 = obj6;
47241 }
47242 {
47243 PyThreadState* __tstate = wxPyBeginAllowThreads();
47244 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47245 wxPyEndAllowThreads(__tstate);
47246 if (PyErr_Occurred()) SWIG_fail;
47247 }
47248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47249 return resultobj;
47250 fail:
47251 return NULL;
47252 }
47253
47254
47255 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47256 PyObject *resultobj = 0;
47257 wxSizer *arg1 = (wxSizer *) 0 ;
47258 PyObject *arg2 = (PyObject *) 0 ;
47259 int arg3 = (int) 0 ;
47260 int arg4 = (int) 0 ;
47261 int arg5 = (int) 0 ;
47262 PyObject *arg6 = (PyObject *) NULL ;
47263 wxSizerItem *result = 0 ;
47264 void *argp1 = 0 ;
47265 int res1 = 0 ;
47266 int val3 ;
47267 int ecode3 = 0 ;
47268 int val4 ;
47269 int ecode4 = 0 ;
47270 int val5 ;
47271 int ecode5 = 0 ;
47272 PyObject * obj0 = 0 ;
47273 PyObject * obj1 = 0 ;
47274 PyObject * obj2 = 0 ;
47275 PyObject * obj3 = 0 ;
47276 PyObject * obj4 = 0 ;
47277 PyObject * obj5 = 0 ;
47278 char * kwnames[] = {
47279 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47280 };
47281
47282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47284 if (!SWIG_IsOK(res1)) {
47285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47286 }
47287 arg1 = reinterpret_cast< wxSizer * >(argp1);
47288 arg2 = obj1;
47289 if (obj2) {
47290 ecode3 = SWIG_AsVal_int(obj2, &val3);
47291 if (!SWIG_IsOK(ecode3)) {
47292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47293 }
47294 arg3 = static_cast< int >(val3);
47295 }
47296 if (obj3) {
47297 ecode4 = SWIG_AsVal_int(obj3, &val4);
47298 if (!SWIG_IsOK(ecode4)) {
47299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47300 }
47301 arg4 = static_cast< int >(val4);
47302 }
47303 if (obj4) {
47304 ecode5 = SWIG_AsVal_int(obj4, &val5);
47305 if (!SWIG_IsOK(ecode5)) {
47306 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47307 }
47308 arg5 = static_cast< int >(val5);
47309 }
47310 if (obj5) {
47311 arg6 = obj5;
47312 }
47313 {
47314 PyThreadState* __tstate = wxPyBeginAllowThreads();
47315 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47316 wxPyEndAllowThreads(__tstate);
47317 if (PyErr_Occurred()) SWIG_fail;
47318 }
47319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47320 return resultobj;
47321 fail:
47322 return NULL;
47323 }
47324
47325
47326 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47327 PyObject *resultobj = 0;
47328 wxSizer *arg1 = (wxSizer *) 0 ;
47329 PyObject *arg2 = (PyObject *) 0 ;
47330 bool result;
47331 void *argp1 = 0 ;
47332 int res1 = 0 ;
47333 PyObject * obj0 = 0 ;
47334 PyObject * obj1 = 0 ;
47335 char * kwnames[] = {
47336 (char *) "self",(char *) "item", NULL
47337 };
47338
47339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47341 if (!SWIG_IsOK(res1)) {
47342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47343 }
47344 arg1 = reinterpret_cast< wxSizer * >(argp1);
47345 arg2 = obj1;
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 result = (bool)wxSizer_Remove(arg1,arg2);
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 {
47353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47354 }
47355 return resultobj;
47356 fail:
47357 return NULL;
47358 }
47359
47360
47361 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47362 PyObject *resultobj = 0;
47363 wxSizer *arg1 = (wxSizer *) 0 ;
47364 PyObject *arg2 = (PyObject *) 0 ;
47365 bool result;
47366 void *argp1 = 0 ;
47367 int res1 = 0 ;
47368 PyObject * obj0 = 0 ;
47369 PyObject * obj1 = 0 ;
47370 char * kwnames[] = {
47371 (char *) "self",(char *) "item", NULL
47372 };
47373
47374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47376 if (!SWIG_IsOK(res1)) {
47377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47378 }
47379 arg1 = reinterpret_cast< wxSizer * >(argp1);
47380 arg2 = obj1;
47381 {
47382 PyThreadState* __tstate = wxPyBeginAllowThreads();
47383 result = (bool)wxSizer_Detach(arg1,arg2);
47384 wxPyEndAllowThreads(__tstate);
47385 if (PyErr_Occurred()) SWIG_fail;
47386 }
47387 {
47388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47389 }
47390 return resultobj;
47391 fail:
47392 return NULL;
47393 }
47394
47395
47396 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47397 PyObject *resultobj = 0;
47398 wxSizer *arg1 = (wxSizer *) 0 ;
47399 PyObject *arg2 = (PyObject *) 0 ;
47400 wxSizerItem *result = 0 ;
47401 void *argp1 = 0 ;
47402 int res1 = 0 ;
47403 PyObject * obj0 = 0 ;
47404 PyObject * obj1 = 0 ;
47405 char * kwnames[] = {
47406 (char *) "self",(char *) "item", NULL
47407 };
47408
47409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47411 if (!SWIG_IsOK(res1)) {
47412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47413 }
47414 arg1 = reinterpret_cast< wxSizer * >(argp1);
47415 arg2 = obj1;
47416 {
47417 PyThreadState* __tstate = wxPyBeginAllowThreads();
47418 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47419 wxPyEndAllowThreads(__tstate);
47420 if (PyErr_Occurred()) SWIG_fail;
47421 }
47422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47423 return resultobj;
47424 fail:
47425 return NULL;
47426 }
47427
47428
47429 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47430 PyObject *resultobj = 0;
47431 wxSizer *arg1 = (wxSizer *) 0 ;
47432 PyObject *arg2 = (PyObject *) 0 ;
47433 wxSize *arg3 = 0 ;
47434 void *argp1 = 0 ;
47435 int res1 = 0 ;
47436 wxSize temp3 ;
47437 PyObject * obj0 = 0 ;
47438 PyObject * obj1 = 0 ;
47439 PyObject * obj2 = 0 ;
47440 char * kwnames[] = {
47441 (char *) "self",(char *) "item",(char *) "size", NULL
47442 };
47443
47444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47446 if (!SWIG_IsOK(res1)) {
47447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47448 }
47449 arg1 = reinterpret_cast< wxSizer * >(argp1);
47450 arg2 = obj1;
47451 {
47452 arg3 = &temp3;
47453 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47454 }
47455 {
47456 PyThreadState* __tstate = wxPyBeginAllowThreads();
47457 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47458 wxPyEndAllowThreads(__tstate);
47459 if (PyErr_Occurred()) SWIG_fail;
47460 }
47461 resultobj = SWIG_Py_Void();
47462 return resultobj;
47463 fail:
47464 return NULL;
47465 }
47466
47467
47468 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47469 PyObject *resultobj = 0;
47470 wxSizer *arg1 = (wxSizer *) 0 ;
47471 wxWindow *arg2 = (wxWindow *) 0 ;
47472 wxWindow *arg3 = (wxWindow *) 0 ;
47473 bool arg4 = (bool) false ;
47474 bool result;
47475 void *argp1 = 0 ;
47476 int res1 = 0 ;
47477 void *argp2 = 0 ;
47478 int res2 = 0 ;
47479 void *argp3 = 0 ;
47480 int res3 = 0 ;
47481 bool val4 ;
47482 int ecode4 = 0 ;
47483 PyObject * obj0 = 0 ;
47484 PyObject * obj1 = 0 ;
47485 PyObject * obj2 = 0 ;
47486 PyObject * obj3 = 0 ;
47487 char * kwnames[] = {
47488 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47489 };
47490
47491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47493 if (!SWIG_IsOK(res1)) {
47494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47495 }
47496 arg1 = reinterpret_cast< wxSizer * >(argp1);
47497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47498 if (!SWIG_IsOK(res2)) {
47499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47500 }
47501 arg2 = reinterpret_cast< wxWindow * >(argp2);
47502 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47503 if (!SWIG_IsOK(res3)) {
47504 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47505 }
47506 arg3 = reinterpret_cast< wxWindow * >(argp3);
47507 if (obj3) {
47508 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47509 if (!SWIG_IsOK(ecode4)) {
47510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47511 }
47512 arg4 = static_cast< bool >(val4);
47513 }
47514 {
47515 PyThreadState* __tstate = wxPyBeginAllowThreads();
47516 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47517 wxPyEndAllowThreads(__tstate);
47518 if (PyErr_Occurred()) SWIG_fail;
47519 }
47520 {
47521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47522 }
47523 return resultobj;
47524 fail:
47525 return NULL;
47526 }
47527
47528
47529 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47530 PyObject *resultobj = 0;
47531 wxSizer *arg1 = (wxSizer *) 0 ;
47532 wxSizer *arg2 = (wxSizer *) 0 ;
47533 wxSizer *arg3 = (wxSizer *) 0 ;
47534 bool arg4 = (bool) false ;
47535 bool result;
47536 void *argp1 = 0 ;
47537 int res1 = 0 ;
47538 void *argp2 = 0 ;
47539 int res2 = 0 ;
47540 void *argp3 = 0 ;
47541 int res3 = 0 ;
47542 bool val4 ;
47543 int ecode4 = 0 ;
47544 PyObject * obj0 = 0 ;
47545 PyObject * obj1 = 0 ;
47546 PyObject * obj2 = 0 ;
47547 PyObject * obj3 = 0 ;
47548 char * kwnames[] = {
47549 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47550 };
47551
47552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47554 if (!SWIG_IsOK(res1)) {
47555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47556 }
47557 arg1 = reinterpret_cast< wxSizer * >(argp1);
47558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47559 if (!SWIG_IsOK(res2)) {
47560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47561 }
47562 arg2 = reinterpret_cast< wxSizer * >(argp2);
47563 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47564 if (!SWIG_IsOK(res3)) {
47565 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47566 }
47567 arg3 = reinterpret_cast< wxSizer * >(argp3);
47568 if (obj3) {
47569 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47570 if (!SWIG_IsOK(ecode4)) {
47571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47572 }
47573 arg4 = static_cast< bool >(val4);
47574 }
47575 {
47576 PyThreadState* __tstate = wxPyBeginAllowThreads();
47577 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47578 wxPyEndAllowThreads(__tstate);
47579 if (PyErr_Occurred()) SWIG_fail;
47580 }
47581 {
47582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47583 }
47584 return resultobj;
47585 fail:
47586 return NULL;
47587 }
47588
47589
47590 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47591 PyObject *resultobj = 0;
47592 wxSizer *arg1 = (wxSizer *) 0 ;
47593 size_t arg2 ;
47594 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47595 bool result;
47596 void *argp1 = 0 ;
47597 int res1 = 0 ;
47598 size_t val2 ;
47599 int ecode2 = 0 ;
47600 void *argp3 = 0 ;
47601 int res3 = 0 ;
47602 PyObject * obj0 = 0 ;
47603 PyObject * obj1 = 0 ;
47604 PyObject * obj2 = 0 ;
47605 char * kwnames[] = {
47606 (char *) "self",(char *) "index",(char *) "newitem", NULL
47607 };
47608
47609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47611 if (!SWIG_IsOK(res1)) {
47612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47613 }
47614 arg1 = reinterpret_cast< wxSizer * >(argp1);
47615 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47616 if (!SWIG_IsOK(ecode2)) {
47617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47618 }
47619 arg2 = static_cast< size_t >(val2);
47620 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47621 if (!SWIG_IsOK(res3)) {
47622 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47623 }
47624 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47625 {
47626 PyThreadState* __tstate = wxPyBeginAllowThreads();
47627 result = (bool)(arg1)->Replace(arg2,arg3);
47628 wxPyEndAllowThreads(__tstate);
47629 if (PyErr_Occurred()) SWIG_fail;
47630 }
47631 {
47632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47633 }
47634 return resultobj;
47635 fail:
47636 return NULL;
47637 }
47638
47639
47640 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47641 PyObject *resultobj = 0;
47642 wxSizer *arg1 = (wxSizer *) 0 ;
47643 wxWindow *arg2 = (wxWindow *) 0 ;
47644 void *argp1 = 0 ;
47645 int res1 = 0 ;
47646 void *argp2 = 0 ;
47647 int res2 = 0 ;
47648 PyObject * obj0 = 0 ;
47649 PyObject * obj1 = 0 ;
47650 char * kwnames[] = {
47651 (char *) "self",(char *) "window", NULL
47652 };
47653
47654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47656 if (!SWIG_IsOK(res1)) {
47657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47658 }
47659 arg1 = reinterpret_cast< wxSizer * >(argp1);
47660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47661 if (!SWIG_IsOK(res2)) {
47662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47663 }
47664 arg2 = reinterpret_cast< wxWindow * >(argp2);
47665 {
47666 PyThreadState* __tstate = wxPyBeginAllowThreads();
47667 (arg1)->SetContainingWindow(arg2);
47668 wxPyEndAllowThreads(__tstate);
47669 if (PyErr_Occurred()) SWIG_fail;
47670 }
47671 resultobj = SWIG_Py_Void();
47672 return resultobj;
47673 fail:
47674 return NULL;
47675 }
47676
47677
47678 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47679 PyObject *resultobj = 0;
47680 wxSizer *arg1 = (wxSizer *) 0 ;
47681 wxWindow *result = 0 ;
47682 void *argp1 = 0 ;
47683 int res1 = 0 ;
47684 PyObject *swig_obj[1] ;
47685
47686 if (!args) SWIG_fail;
47687 swig_obj[0] = args;
47688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47689 if (!SWIG_IsOK(res1)) {
47690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47691 }
47692 arg1 = reinterpret_cast< wxSizer * >(argp1);
47693 {
47694 PyThreadState* __tstate = wxPyBeginAllowThreads();
47695 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47696 wxPyEndAllowThreads(__tstate);
47697 if (PyErr_Occurred()) SWIG_fail;
47698 }
47699 {
47700 resultobj = wxPyMake_wxObject(result, 0);
47701 }
47702 return resultobj;
47703 fail:
47704 return NULL;
47705 }
47706
47707
47708 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47709 PyObject *resultobj = 0;
47710 wxSizer *arg1 = (wxSizer *) 0 ;
47711 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47712 wxSizerItem *result = 0 ;
47713 void *argp1 = 0 ;
47714 int res1 = 0 ;
47715 int res2 = 0 ;
47716 PyObject * obj0 = 0 ;
47717 PyObject * obj1 = 0 ;
47718 char * kwnames[] = {
47719 (char *) "self",(char *) "item", NULL
47720 };
47721
47722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47724 if (!SWIG_IsOK(res1)) {
47725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47726 }
47727 arg1 = reinterpret_cast< wxSizer * >(argp1);
47728 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47729 if (!SWIG_IsOK(res2)) {
47730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47731 }
47732 {
47733 PyThreadState* __tstate = wxPyBeginAllowThreads();
47734 result = (wxSizerItem *)(arg1)->Add(arg2);
47735 wxPyEndAllowThreads(__tstate);
47736 if (PyErr_Occurred()) SWIG_fail;
47737 }
47738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47739 return resultobj;
47740 fail:
47741 return NULL;
47742 }
47743
47744
47745 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47746 PyObject *resultobj = 0;
47747 wxSizer *arg1 = (wxSizer *) 0 ;
47748 size_t arg2 ;
47749 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47750 wxSizerItem *result = 0 ;
47751 void *argp1 = 0 ;
47752 int res1 = 0 ;
47753 size_t val2 ;
47754 int ecode2 = 0 ;
47755 int res3 = 0 ;
47756 PyObject * obj0 = 0 ;
47757 PyObject * obj1 = 0 ;
47758 PyObject * obj2 = 0 ;
47759 char * kwnames[] = {
47760 (char *) "self",(char *) "index",(char *) "item", NULL
47761 };
47762
47763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47765 if (!SWIG_IsOK(res1)) {
47766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47767 }
47768 arg1 = reinterpret_cast< wxSizer * >(argp1);
47769 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47770 if (!SWIG_IsOK(ecode2)) {
47771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47772 }
47773 arg2 = static_cast< size_t >(val2);
47774 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47775 if (!SWIG_IsOK(res3)) {
47776 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47777 }
47778 {
47779 PyThreadState* __tstate = wxPyBeginAllowThreads();
47780 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47781 wxPyEndAllowThreads(__tstate);
47782 if (PyErr_Occurred()) SWIG_fail;
47783 }
47784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47785 return resultobj;
47786 fail:
47787 return NULL;
47788 }
47789
47790
47791 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47792 PyObject *resultobj = 0;
47793 wxSizer *arg1 = (wxSizer *) 0 ;
47794 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47795 wxSizerItem *result = 0 ;
47796 void *argp1 = 0 ;
47797 int res1 = 0 ;
47798 int res2 = 0 ;
47799 PyObject * obj0 = 0 ;
47800 PyObject * obj1 = 0 ;
47801 char * kwnames[] = {
47802 (char *) "self",(char *) "item", NULL
47803 };
47804
47805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47807 if (!SWIG_IsOK(res1)) {
47808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47809 }
47810 arg1 = reinterpret_cast< wxSizer * >(argp1);
47811 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47812 if (!SWIG_IsOK(res2)) {
47813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47814 }
47815 {
47816 PyThreadState* __tstate = wxPyBeginAllowThreads();
47817 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47818 wxPyEndAllowThreads(__tstate);
47819 if (PyErr_Occurred()) SWIG_fail;
47820 }
47821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47822 return resultobj;
47823 fail:
47824 return NULL;
47825 }
47826
47827
47828 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47829 PyObject *resultobj = 0;
47830 wxSizer *arg1 = (wxSizer *) 0 ;
47831 int arg2 ;
47832 int arg3 ;
47833 int arg4 ;
47834 int arg5 ;
47835 void *argp1 = 0 ;
47836 int res1 = 0 ;
47837 int val2 ;
47838 int ecode2 = 0 ;
47839 int val3 ;
47840 int ecode3 = 0 ;
47841 int val4 ;
47842 int ecode4 = 0 ;
47843 int val5 ;
47844 int ecode5 = 0 ;
47845 PyObject * obj0 = 0 ;
47846 PyObject * obj1 = 0 ;
47847 PyObject * obj2 = 0 ;
47848 PyObject * obj3 = 0 ;
47849 PyObject * obj4 = 0 ;
47850 char * kwnames[] = {
47851 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47852 };
47853
47854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47856 if (!SWIG_IsOK(res1)) {
47857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47858 }
47859 arg1 = reinterpret_cast< wxSizer * >(argp1);
47860 ecode2 = SWIG_AsVal_int(obj1, &val2);
47861 if (!SWIG_IsOK(ecode2)) {
47862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47863 }
47864 arg2 = static_cast< int >(val2);
47865 ecode3 = SWIG_AsVal_int(obj2, &val3);
47866 if (!SWIG_IsOK(ecode3)) {
47867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47868 }
47869 arg3 = static_cast< int >(val3);
47870 ecode4 = SWIG_AsVal_int(obj3, &val4);
47871 if (!SWIG_IsOK(ecode4)) {
47872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47873 }
47874 arg4 = static_cast< int >(val4);
47875 ecode5 = SWIG_AsVal_int(obj4, &val5);
47876 if (!SWIG_IsOK(ecode5)) {
47877 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47878 }
47879 arg5 = static_cast< int >(val5);
47880 {
47881 PyThreadState* __tstate = wxPyBeginAllowThreads();
47882 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47883 wxPyEndAllowThreads(__tstate);
47884 if (PyErr_Occurred()) SWIG_fail;
47885 }
47886 resultobj = SWIG_Py_Void();
47887 return resultobj;
47888 fail:
47889 return NULL;
47890 }
47891
47892
47893 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47894 PyObject *resultobj = 0;
47895 wxSizer *arg1 = (wxSizer *) 0 ;
47896 wxSize *arg2 = 0 ;
47897 void *argp1 = 0 ;
47898 int res1 = 0 ;
47899 wxSize temp2 ;
47900 PyObject * obj0 = 0 ;
47901 PyObject * obj1 = 0 ;
47902 char * kwnames[] = {
47903 (char *) "self",(char *) "size", NULL
47904 };
47905
47906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47908 if (!SWIG_IsOK(res1)) {
47909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47910 }
47911 arg1 = reinterpret_cast< wxSizer * >(argp1);
47912 {
47913 arg2 = &temp2;
47914 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47915 }
47916 {
47917 PyThreadState* __tstate = wxPyBeginAllowThreads();
47918 (arg1)->SetMinSize((wxSize const &)*arg2);
47919 wxPyEndAllowThreads(__tstate);
47920 if (PyErr_Occurred()) SWIG_fail;
47921 }
47922 resultobj = SWIG_Py_Void();
47923 return resultobj;
47924 fail:
47925 return NULL;
47926 }
47927
47928
47929 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47930 PyObject *resultobj = 0;
47931 wxSizer *arg1 = (wxSizer *) 0 ;
47932 wxSize result;
47933 void *argp1 = 0 ;
47934 int res1 = 0 ;
47935 PyObject *swig_obj[1] ;
47936
47937 if (!args) SWIG_fail;
47938 swig_obj[0] = args;
47939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47940 if (!SWIG_IsOK(res1)) {
47941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47942 }
47943 arg1 = reinterpret_cast< wxSizer * >(argp1);
47944 {
47945 PyThreadState* __tstate = wxPyBeginAllowThreads();
47946 result = (arg1)->GetSize();
47947 wxPyEndAllowThreads(__tstate);
47948 if (PyErr_Occurred()) SWIG_fail;
47949 }
47950 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47951 return resultobj;
47952 fail:
47953 return NULL;
47954 }
47955
47956
47957 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47958 PyObject *resultobj = 0;
47959 wxSizer *arg1 = (wxSizer *) 0 ;
47960 wxPoint result;
47961 void *argp1 = 0 ;
47962 int res1 = 0 ;
47963 PyObject *swig_obj[1] ;
47964
47965 if (!args) SWIG_fail;
47966 swig_obj[0] = args;
47967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47968 if (!SWIG_IsOK(res1)) {
47969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47970 }
47971 arg1 = reinterpret_cast< wxSizer * >(argp1);
47972 {
47973 PyThreadState* __tstate = wxPyBeginAllowThreads();
47974 result = (arg1)->GetPosition();
47975 wxPyEndAllowThreads(__tstate);
47976 if (PyErr_Occurred()) SWIG_fail;
47977 }
47978 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47979 return resultobj;
47980 fail:
47981 return NULL;
47982 }
47983
47984
47985 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47986 PyObject *resultobj = 0;
47987 wxSizer *arg1 = (wxSizer *) 0 ;
47988 wxSize result;
47989 void *argp1 = 0 ;
47990 int res1 = 0 ;
47991 PyObject *swig_obj[1] ;
47992
47993 if (!args) SWIG_fail;
47994 swig_obj[0] = args;
47995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47996 if (!SWIG_IsOK(res1)) {
47997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47998 }
47999 arg1 = reinterpret_cast< wxSizer * >(argp1);
48000 {
48001 PyThreadState* __tstate = wxPyBeginAllowThreads();
48002 result = (arg1)->GetMinSize();
48003 wxPyEndAllowThreads(__tstate);
48004 if (PyErr_Occurred()) SWIG_fail;
48005 }
48006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48007 return resultobj;
48008 fail:
48009 return NULL;
48010 }
48011
48012
48013 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48014 PyObject *resultobj = 0;
48015 wxSizer *arg1 = (wxSizer *) 0 ;
48016 void *argp1 = 0 ;
48017 int res1 = 0 ;
48018 PyObject *swig_obj[1] ;
48019
48020 if (!args) SWIG_fail;
48021 swig_obj[0] = args;
48022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48023 if (!SWIG_IsOK(res1)) {
48024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48025 }
48026 arg1 = reinterpret_cast< wxSizer * >(argp1);
48027 {
48028 PyThreadState* __tstate = wxPyBeginAllowThreads();
48029 (arg1)->RecalcSizes();
48030 wxPyEndAllowThreads(__tstate);
48031 if (PyErr_Occurred()) SWIG_fail;
48032 }
48033 resultobj = SWIG_Py_Void();
48034 return resultobj;
48035 fail:
48036 return NULL;
48037 }
48038
48039
48040 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48041 PyObject *resultobj = 0;
48042 wxSizer *arg1 = (wxSizer *) 0 ;
48043 wxSize result;
48044 void *argp1 = 0 ;
48045 int res1 = 0 ;
48046 PyObject *swig_obj[1] ;
48047
48048 if (!args) SWIG_fail;
48049 swig_obj[0] = args;
48050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48051 if (!SWIG_IsOK(res1)) {
48052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48053 }
48054 arg1 = reinterpret_cast< wxSizer * >(argp1);
48055 {
48056 PyThreadState* __tstate = wxPyBeginAllowThreads();
48057 result = (arg1)->CalcMin();
48058 wxPyEndAllowThreads(__tstate);
48059 if (PyErr_Occurred()) SWIG_fail;
48060 }
48061 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48062 return resultobj;
48063 fail:
48064 return NULL;
48065 }
48066
48067
48068 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48069 PyObject *resultobj = 0;
48070 wxSizer *arg1 = (wxSizer *) 0 ;
48071 void *argp1 = 0 ;
48072 int res1 = 0 ;
48073 PyObject *swig_obj[1] ;
48074
48075 if (!args) SWIG_fail;
48076 swig_obj[0] = args;
48077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48078 if (!SWIG_IsOK(res1)) {
48079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48080 }
48081 arg1 = reinterpret_cast< wxSizer * >(argp1);
48082 {
48083 PyThreadState* __tstate = wxPyBeginAllowThreads();
48084 (arg1)->Layout();
48085 wxPyEndAllowThreads(__tstate);
48086 if (PyErr_Occurred()) SWIG_fail;
48087 }
48088 resultobj = SWIG_Py_Void();
48089 return resultobj;
48090 fail:
48091 return NULL;
48092 }
48093
48094
48095 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48096 PyObject *resultobj = 0;
48097 wxSizer *arg1 = (wxSizer *) 0 ;
48098 wxWindow *arg2 = (wxWindow *) 0 ;
48099 wxSize result;
48100 void *argp1 = 0 ;
48101 int res1 = 0 ;
48102 void *argp2 = 0 ;
48103 int res2 = 0 ;
48104 PyObject * obj0 = 0 ;
48105 PyObject * obj1 = 0 ;
48106 char * kwnames[] = {
48107 (char *) "self",(char *) "window", NULL
48108 };
48109
48110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48112 if (!SWIG_IsOK(res1)) {
48113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48114 }
48115 arg1 = reinterpret_cast< wxSizer * >(argp1);
48116 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48117 if (!SWIG_IsOK(res2)) {
48118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48119 }
48120 arg2 = reinterpret_cast< wxWindow * >(argp2);
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 result = (arg1)->Fit(arg2);
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48128 return resultobj;
48129 fail:
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48135 PyObject *resultobj = 0;
48136 wxSizer *arg1 = (wxSizer *) 0 ;
48137 wxWindow *arg2 = (wxWindow *) 0 ;
48138 void *argp1 = 0 ;
48139 int res1 = 0 ;
48140 void *argp2 = 0 ;
48141 int res2 = 0 ;
48142 PyObject * obj0 = 0 ;
48143 PyObject * obj1 = 0 ;
48144 char * kwnames[] = {
48145 (char *) "self",(char *) "window", NULL
48146 };
48147
48148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48150 if (!SWIG_IsOK(res1)) {
48151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48152 }
48153 arg1 = reinterpret_cast< wxSizer * >(argp1);
48154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48155 if (!SWIG_IsOK(res2)) {
48156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48157 }
48158 arg2 = reinterpret_cast< wxWindow * >(argp2);
48159 {
48160 PyThreadState* __tstate = wxPyBeginAllowThreads();
48161 (arg1)->FitInside(arg2);
48162 wxPyEndAllowThreads(__tstate);
48163 if (PyErr_Occurred()) SWIG_fail;
48164 }
48165 resultobj = SWIG_Py_Void();
48166 return resultobj;
48167 fail:
48168 return NULL;
48169 }
48170
48171
48172 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48173 PyObject *resultobj = 0;
48174 wxSizer *arg1 = (wxSizer *) 0 ;
48175 wxWindow *arg2 = (wxWindow *) 0 ;
48176 void *argp1 = 0 ;
48177 int res1 = 0 ;
48178 void *argp2 = 0 ;
48179 int res2 = 0 ;
48180 PyObject * obj0 = 0 ;
48181 PyObject * obj1 = 0 ;
48182 char * kwnames[] = {
48183 (char *) "self",(char *) "window", NULL
48184 };
48185
48186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48188 if (!SWIG_IsOK(res1)) {
48189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48190 }
48191 arg1 = reinterpret_cast< wxSizer * >(argp1);
48192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48193 if (!SWIG_IsOK(res2)) {
48194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48195 }
48196 arg2 = reinterpret_cast< wxWindow * >(argp2);
48197 {
48198 PyThreadState* __tstate = wxPyBeginAllowThreads();
48199 (arg1)->SetSizeHints(arg2);
48200 wxPyEndAllowThreads(__tstate);
48201 if (PyErr_Occurred()) SWIG_fail;
48202 }
48203 resultobj = SWIG_Py_Void();
48204 return resultobj;
48205 fail:
48206 return NULL;
48207 }
48208
48209
48210 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48211 PyObject *resultobj = 0;
48212 wxSizer *arg1 = (wxSizer *) 0 ;
48213 wxWindow *arg2 = (wxWindow *) 0 ;
48214 void *argp1 = 0 ;
48215 int res1 = 0 ;
48216 void *argp2 = 0 ;
48217 int res2 = 0 ;
48218 PyObject * obj0 = 0 ;
48219 PyObject * obj1 = 0 ;
48220 char * kwnames[] = {
48221 (char *) "self",(char *) "window", NULL
48222 };
48223
48224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48226 if (!SWIG_IsOK(res1)) {
48227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48228 }
48229 arg1 = reinterpret_cast< wxSizer * >(argp1);
48230 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48231 if (!SWIG_IsOK(res2)) {
48232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48233 }
48234 arg2 = reinterpret_cast< wxWindow * >(argp2);
48235 {
48236 PyThreadState* __tstate = wxPyBeginAllowThreads();
48237 (arg1)->SetVirtualSizeHints(arg2);
48238 wxPyEndAllowThreads(__tstate);
48239 if (PyErr_Occurred()) SWIG_fail;
48240 }
48241 resultobj = SWIG_Py_Void();
48242 return resultobj;
48243 fail:
48244 return NULL;
48245 }
48246
48247
48248 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48249 PyObject *resultobj = 0;
48250 wxSizer *arg1 = (wxSizer *) 0 ;
48251 bool arg2 = (bool) false ;
48252 void *argp1 = 0 ;
48253 int res1 = 0 ;
48254 bool val2 ;
48255 int ecode2 = 0 ;
48256 PyObject * obj0 = 0 ;
48257 PyObject * obj1 = 0 ;
48258 char * kwnames[] = {
48259 (char *) "self",(char *) "deleteWindows", NULL
48260 };
48261
48262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48264 if (!SWIG_IsOK(res1)) {
48265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48266 }
48267 arg1 = reinterpret_cast< wxSizer * >(argp1);
48268 if (obj1) {
48269 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48270 if (!SWIG_IsOK(ecode2)) {
48271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48272 }
48273 arg2 = static_cast< bool >(val2);
48274 }
48275 {
48276 PyThreadState* __tstate = wxPyBeginAllowThreads();
48277 (arg1)->Clear(arg2);
48278 wxPyEndAllowThreads(__tstate);
48279 if (PyErr_Occurred()) SWIG_fail;
48280 }
48281 resultobj = SWIG_Py_Void();
48282 return resultobj;
48283 fail:
48284 return NULL;
48285 }
48286
48287
48288 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48289 PyObject *resultobj = 0;
48290 wxSizer *arg1 = (wxSizer *) 0 ;
48291 void *argp1 = 0 ;
48292 int res1 = 0 ;
48293 PyObject *swig_obj[1] ;
48294
48295 if (!args) SWIG_fail;
48296 swig_obj[0] = args;
48297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48298 if (!SWIG_IsOK(res1)) {
48299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48300 }
48301 arg1 = reinterpret_cast< wxSizer * >(argp1);
48302 {
48303 PyThreadState* __tstate = wxPyBeginAllowThreads();
48304 (arg1)->DeleteWindows();
48305 wxPyEndAllowThreads(__tstate);
48306 if (PyErr_Occurred()) SWIG_fail;
48307 }
48308 resultobj = SWIG_Py_Void();
48309 return resultobj;
48310 fail:
48311 return NULL;
48312 }
48313
48314
48315 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48316 PyObject *resultobj = 0;
48317 wxSizer *arg1 = (wxSizer *) 0 ;
48318 PyObject *result = 0 ;
48319 void *argp1 = 0 ;
48320 int res1 = 0 ;
48321 PyObject *swig_obj[1] ;
48322
48323 if (!args) SWIG_fail;
48324 swig_obj[0] = args;
48325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48326 if (!SWIG_IsOK(res1)) {
48327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48328 }
48329 arg1 = reinterpret_cast< wxSizer * >(argp1);
48330 {
48331 PyThreadState* __tstate = wxPyBeginAllowThreads();
48332 result = (PyObject *)wxSizer_GetChildren(arg1);
48333 wxPyEndAllowThreads(__tstate);
48334 if (PyErr_Occurred()) SWIG_fail;
48335 }
48336 resultobj = result;
48337 return resultobj;
48338 fail:
48339 return NULL;
48340 }
48341
48342
48343 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48344 PyObject *resultobj = 0;
48345 wxSizer *arg1 = (wxSizer *) 0 ;
48346 PyObject *arg2 = (PyObject *) 0 ;
48347 bool arg3 = (bool) true ;
48348 bool arg4 = (bool) false ;
48349 bool result;
48350 void *argp1 = 0 ;
48351 int res1 = 0 ;
48352 bool val3 ;
48353 int ecode3 = 0 ;
48354 bool val4 ;
48355 int ecode4 = 0 ;
48356 PyObject * obj0 = 0 ;
48357 PyObject * obj1 = 0 ;
48358 PyObject * obj2 = 0 ;
48359 PyObject * obj3 = 0 ;
48360 char * kwnames[] = {
48361 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48362 };
48363
48364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48366 if (!SWIG_IsOK(res1)) {
48367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48368 }
48369 arg1 = reinterpret_cast< wxSizer * >(argp1);
48370 arg2 = obj1;
48371 if (obj2) {
48372 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48373 if (!SWIG_IsOK(ecode3)) {
48374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48375 }
48376 arg3 = static_cast< bool >(val3);
48377 }
48378 if (obj3) {
48379 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48380 if (!SWIG_IsOK(ecode4)) {
48381 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48382 }
48383 arg4 = static_cast< bool >(val4);
48384 }
48385 {
48386 PyThreadState* __tstate = wxPyBeginAllowThreads();
48387 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48388 wxPyEndAllowThreads(__tstate);
48389 if (PyErr_Occurred()) SWIG_fail;
48390 }
48391 {
48392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48393 }
48394 return resultobj;
48395 fail:
48396 return NULL;
48397 }
48398
48399
48400 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48401 PyObject *resultobj = 0;
48402 wxSizer *arg1 = (wxSizer *) 0 ;
48403 PyObject *arg2 = (PyObject *) 0 ;
48404 bool result;
48405 void *argp1 = 0 ;
48406 int res1 = 0 ;
48407 PyObject * obj0 = 0 ;
48408 PyObject * obj1 = 0 ;
48409 char * kwnames[] = {
48410 (char *) "self",(char *) "item", NULL
48411 };
48412
48413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48415 if (!SWIG_IsOK(res1)) {
48416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48417 }
48418 arg1 = reinterpret_cast< wxSizer * >(argp1);
48419 arg2 = obj1;
48420 {
48421 PyThreadState* __tstate = wxPyBeginAllowThreads();
48422 result = (bool)wxSizer_IsShown(arg1,arg2);
48423 wxPyEndAllowThreads(__tstate);
48424 if (PyErr_Occurred()) SWIG_fail;
48425 }
48426 {
48427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48428 }
48429 return resultobj;
48430 fail:
48431 return NULL;
48432 }
48433
48434
48435 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48436 PyObject *resultobj = 0;
48437 wxSizer *arg1 = (wxSizer *) 0 ;
48438 bool arg2 ;
48439 void *argp1 = 0 ;
48440 int res1 = 0 ;
48441 bool val2 ;
48442 int ecode2 = 0 ;
48443 PyObject * obj0 = 0 ;
48444 PyObject * obj1 = 0 ;
48445 char * kwnames[] = {
48446 (char *) "self",(char *) "show", NULL
48447 };
48448
48449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48451 if (!SWIG_IsOK(res1)) {
48452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48453 }
48454 arg1 = reinterpret_cast< wxSizer * >(argp1);
48455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48456 if (!SWIG_IsOK(ecode2)) {
48457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48458 }
48459 arg2 = static_cast< bool >(val2);
48460 {
48461 PyThreadState* __tstate = wxPyBeginAllowThreads();
48462 (arg1)->ShowItems(arg2);
48463 wxPyEndAllowThreads(__tstate);
48464 if (PyErr_Occurred()) SWIG_fail;
48465 }
48466 resultobj = SWIG_Py_Void();
48467 return resultobj;
48468 fail:
48469 return NULL;
48470 }
48471
48472
48473 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48474 PyObject *obj;
48475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48476 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48477 return SWIG_Py_Void();
48478 }
48479
48480 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48481 PyObject *resultobj = 0;
48482 wxPySizer *result = 0 ;
48483
48484 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48485 {
48486 PyThreadState* __tstate = wxPyBeginAllowThreads();
48487 result = (wxPySizer *)new wxPySizer();
48488 wxPyEndAllowThreads(__tstate);
48489 if (PyErr_Occurred()) SWIG_fail;
48490 }
48491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48492 return resultobj;
48493 fail:
48494 return NULL;
48495 }
48496
48497
48498 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48499 PyObject *resultobj = 0;
48500 wxPySizer *arg1 = (wxPySizer *) 0 ;
48501 PyObject *arg2 = (PyObject *) 0 ;
48502 PyObject *arg3 = (PyObject *) 0 ;
48503 void *argp1 = 0 ;
48504 int res1 = 0 ;
48505 PyObject * obj0 = 0 ;
48506 PyObject * obj1 = 0 ;
48507 PyObject * obj2 = 0 ;
48508 char * kwnames[] = {
48509 (char *) "self",(char *) "self",(char *) "_class", NULL
48510 };
48511
48512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48514 if (!SWIG_IsOK(res1)) {
48515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48516 }
48517 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48518 arg2 = obj1;
48519 arg3 = obj2;
48520 {
48521 PyThreadState* __tstate = wxPyBeginAllowThreads();
48522 (arg1)->_setCallbackInfo(arg2,arg3);
48523 wxPyEndAllowThreads(__tstate);
48524 if (PyErr_Occurred()) SWIG_fail;
48525 }
48526 resultobj = SWIG_Py_Void();
48527 return resultobj;
48528 fail:
48529 return NULL;
48530 }
48531
48532
48533 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48534 PyObject *obj;
48535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48536 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48537 return SWIG_Py_Void();
48538 }
48539
48540 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48541 return SWIG_Python_InitShadowInstance(args);
48542 }
48543
48544 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48545 PyObject *resultobj = 0;
48546 int arg1 = (int) wxHORIZONTAL ;
48547 wxBoxSizer *result = 0 ;
48548 int val1 ;
48549 int ecode1 = 0 ;
48550 PyObject * obj0 = 0 ;
48551 char * kwnames[] = {
48552 (char *) "orient", NULL
48553 };
48554
48555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48556 if (obj0) {
48557 ecode1 = SWIG_AsVal_int(obj0, &val1);
48558 if (!SWIG_IsOK(ecode1)) {
48559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48560 }
48561 arg1 = static_cast< int >(val1);
48562 }
48563 {
48564 PyThreadState* __tstate = wxPyBeginAllowThreads();
48565 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48566 wxPyEndAllowThreads(__tstate);
48567 if (PyErr_Occurred()) SWIG_fail;
48568 }
48569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48570 return resultobj;
48571 fail:
48572 return NULL;
48573 }
48574
48575
48576 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48577 PyObject *resultobj = 0;
48578 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48579 int result;
48580 void *argp1 = 0 ;
48581 int res1 = 0 ;
48582 PyObject *swig_obj[1] ;
48583
48584 if (!args) SWIG_fail;
48585 swig_obj[0] = args;
48586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48587 if (!SWIG_IsOK(res1)) {
48588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48589 }
48590 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48591 {
48592 PyThreadState* __tstate = wxPyBeginAllowThreads();
48593 result = (int)(arg1)->GetOrientation();
48594 wxPyEndAllowThreads(__tstate);
48595 if (PyErr_Occurred()) SWIG_fail;
48596 }
48597 resultobj = SWIG_From_int(static_cast< int >(result));
48598 return resultobj;
48599 fail:
48600 return NULL;
48601 }
48602
48603
48604 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48605 PyObject *resultobj = 0;
48606 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48607 int arg2 ;
48608 void *argp1 = 0 ;
48609 int res1 = 0 ;
48610 int val2 ;
48611 int ecode2 = 0 ;
48612 PyObject * obj0 = 0 ;
48613 PyObject * obj1 = 0 ;
48614 char * kwnames[] = {
48615 (char *) "self",(char *) "orient", NULL
48616 };
48617
48618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48620 if (!SWIG_IsOK(res1)) {
48621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48622 }
48623 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48624 ecode2 = SWIG_AsVal_int(obj1, &val2);
48625 if (!SWIG_IsOK(ecode2)) {
48626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48627 }
48628 arg2 = static_cast< int >(val2);
48629 {
48630 PyThreadState* __tstate = wxPyBeginAllowThreads();
48631 (arg1)->SetOrientation(arg2);
48632 wxPyEndAllowThreads(__tstate);
48633 if (PyErr_Occurred()) SWIG_fail;
48634 }
48635 resultobj = SWIG_Py_Void();
48636 return resultobj;
48637 fail:
48638 return NULL;
48639 }
48640
48641
48642 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48643 PyObject *obj;
48644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48645 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48646 return SWIG_Py_Void();
48647 }
48648
48649 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48650 return SWIG_Python_InitShadowInstance(args);
48651 }
48652
48653 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48654 PyObject *resultobj = 0;
48655 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48656 int arg2 = (int) wxHORIZONTAL ;
48657 wxStaticBoxSizer *result = 0 ;
48658 void *argp1 = 0 ;
48659 int res1 = 0 ;
48660 int val2 ;
48661 int ecode2 = 0 ;
48662 PyObject * obj0 = 0 ;
48663 PyObject * obj1 = 0 ;
48664 char * kwnames[] = {
48665 (char *) "box",(char *) "orient", NULL
48666 };
48667
48668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48670 if (!SWIG_IsOK(res1)) {
48671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48672 }
48673 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48674 if (obj1) {
48675 ecode2 = SWIG_AsVal_int(obj1, &val2);
48676 if (!SWIG_IsOK(ecode2)) {
48677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48678 }
48679 arg2 = static_cast< int >(val2);
48680 }
48681 {
48682 PyThreadState* __tstate = wxPyBeginAllowThreads();
48683 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48684 wxPyEndAllowThreads(__tstate);
48685 if (PyErr_Occurred()) SWIG_fail;
48686 }
48687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48688 return resultobj;
48689 fail:
48690 return NULL;
48691 }
48692
48693
48694 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48695 PyObject *resultobj = 0;
48696 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48697 wxStaticBox *result = 0 ;
48698 void *argp1 = 0 ;
48699 int res1 = 0 ;
48700 PyObject *swig_obj[1] ;
48701
48702 if (!args) SWIG_fail;
48703 swig_obj[0] = args;
48704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48705 if (!SWIG_IsOK(res1)) {
48706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48707 }
48708 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48709 {
48710 PyThreadState* __tstate = wxPyBeginAllowThreads();
48711 result = (wxStaticBox *)(arg1)->GetStaticBox();
48712 wxPyEndAllowThreads(__tstate);
48713 if (PyErr_Occurred()) SWIG_fail;
48714 }
48715 {
48716 resultobj = wxPyMake_wxObject(result, (bool)0);
48717 }
48718 return resultobj;
48719 fail:
48720 return NULL;
48721 }
48722
48723
48724 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48725 PyObject *obj;
48726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48727 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48728 return SWIG_Py_Void();
48729 }
48730
48731 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48732 return SWIG_Python_InitShadowInstance(args);
48733 }
48734
48735 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48736 PyObject *resultobj = 0;
48737 int arg1 = (int) 1 ;
48738 int arg2 = (int) 0 ;
48739 int arg3 = (int) 0 ;
48740 int arg4 = (int) 0 ;
48741 wxGridSizer *result = 0 ;
48742 int val1 ;
48743 int ecode1 = 0 ;
48744 int val2 ;
48745 int ecode2 = 0 ;
48746 int val3 ;
48747 int ecode3 = 0 ;
48748 int val4 ;
48749 int ecode4 = 0 ;
48750 PyObject * obj0 = 0 ;
48751 PyObject * obj1 = 0 ;
48752 PyObject * obj2 = 0 ;
48753 PyObject * obj3 = 0 ;
48754 char * kwnames[] = {
48755 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48756 };
48757
48758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48759 if (obj0) {
48760 ecode1 = SWIG_AsVal_int(obj0, &val1);
48761 if (!SWIG_IsOK(ecode1)) {
48762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48763 }
48764 arg1 = static_cast< int >(val1);
48765 }
48766 if (obj1) {
48767 ecode2 = SWIG_AsVal_int(obj1, &val2);
48768 if (!SWIG_IsOK(ecode2)) {
48769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48770 }
48771 arg2 = static_cast< int >(val2);
48772 }
48773 if (obj2) {
48774 ecode3 = SWIG_AsVal_int(obj2, &val3);
48775 if (!SWIG_IsOK(ecode3)) {
48776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48777 }
48778 arg3 = static_cast< int >(val3);
48779 }
48780 if (obj3) {
48781 ecode4 = SWIG_AsVal_int(obj3, &val4);
48782 if (!SWIG_IsOK(ecode4)) {
48783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48784 }
48785 arg4 = static_cast< int >(val4);
48786 }
48787 {
48788 PyThreadState* __tstate = wxPyBeginAllowThreads();
48789 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48790 wxPyEndAllowThreads(__tstate);
48791 if (PyErr_Occurred()) SWIG_fail;
48792 }
48793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48794 return resultobj;
48795 fail:
48796 return NULL;
48797 }
48798
48799
48800 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48801 PyObject *resultobj = 0;
48802 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48803 int arg2 ;
48804 void *argp1 = 0 ;
48805 int res1 = 0 ;
48806 int val2 ;
48807 int ecode2 = 0 ;
48808 PyObject * obj0 = 0 ;
48809 PyObject * obj1 = 0 ;
48810 char * kwnames[] = {
48811 (char *) "self",(char *) "cols", NULL
48812 };
48813
48814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48816 if (!SWIG_IsOK(res1)) {
48817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48818 }
48819 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48820 ecode2 = SWIG_AsVal_int(obj1, &val2);
48821 if (!SWIG_IsOK(ecode2)) {
48822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48823 }
48824 arg2 = static_cast< int >(val2);
48825 {
48826 PyThreadState* __tstate = wxPyBeginAllowThreads();
48827 (arg1)->SetCols(arg2);
48828 wxPyEndAllowThreads(__tstate);
48829 if (PyErr_Occurred()) SWIG_fail;
48830 }
48831 resultobj = SWIG_Py_Void();
48832 return resultobj;
48833 fail:
48834 return NULL;
48835 }
48836
48837
48838 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48839 PyObject *resultobj = 0;
48840 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48841 int arg2 ;
48842 void *argp1 = 0 ;
48843 int res1 = 0 ;
48844 int val2 ;
48845 int ecode2 = 0 ;
48846 PyObject * obj0 = 0 ;
48847 PyObject * obj1 = 0 ;
48848 char * kwnames[] = {
48849 (char *) "self",(char *) "rows", NULL
48850 };
48851
48852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48854 if (!SWIG_IsOK(res1)) {
48855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48856 }
48857 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48858 ecode2 = SWIG_AsVal_int(obj1, &val2);
48859 if (!SWIG_IsOK(ecode2)) {
48860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48861 }
48862 arg2 = static_cast< int >(val2);
48863 {
48864 PyThreadState* __tstate = wxPyBeginAllowThreads();
48865 (arg1)->SetRows(arg2);
48866 wxPyEndAllowThreads(__tstate);
48867 if (PyErr_Occurred()) SWIG_fail;
48868 }
48869 resultobj = SWIG_Py_Void();
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48877 PyObject *resultobj = 0;
48878 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48879 int arg2 ;
48880 void *argp1 = 0 ;
48881 int res1 = 0 ;
48882 int val2 ;
48883 int ecode2 = 0 ;
48884 PyObject * obj0 = 0 ;
48885 PyObject * obj1 = 0 ;
48886 char * kwnames[] = {
48887 (char *) "self",(char *) "gap", NULL
48888 };
48889
48890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48892 if (!SWIG_IsOK(res1)) {
48893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48894 }
48895 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48896 ecode2 = SWIG_AsVal_int(obj1, &val2);
48897 if (!SWIG_IsOK(ecode2)) {
48898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48899 }
48900 arg2 = static_cast< int >(val2);
48901 {
48902 PyThreadState* __tstate = wxPyBeginAllowThreads();
48903 (arg1)->SetVGap(arg2);
48904 wxPyEndAllowThreads(__tstate);
48905 if (PyErr_Occurred()) SWIG_fail;
48906 }
48907 resultobj = SWIG_Py_Void();
48908 return resultobj;
48909 fail:
48910 return NULL;
48911 }
48912
48913
48914 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48915 PyObject *resultobj = 0;
48916 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48917 int arg2 ;
48918 void *argp1 = 0 ;
48919 int res1 = 0 ;
48920 int val2 ;
48921 int ecode2 = 0 ;
48922 PyObject * obj0 = 0 ;
48923 PyObject * obj1 = 0 ;
48924 char * kwnames[] = {
48925 (char *) "self",(char *) "gap", NULL
48926 };
48927
48928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48930 if (!SWIG_IsOK(res1)) {
48931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48932 }
48933 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48934 ecode2 = SWIG_AsVal_int(obj1, &val2);
48935 if (!SWIG_IsOK(ecode2)) {
48936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48937 }
48938 arg2 = static_cast< int >(val2);
48939 {
48940 PyThreadState* __tstate = wxPyBeginAllowThreads();
48941 (arg1)->SetHGap(arg2);
48942 wxPyEndAllowThreads(__tstate);
48943 if (PyErr_Occurred()) SWIG_fail;
48944 }
48945 resultobj = SWIG_Py_Void();
48946 return resultobj;
48947 fail:
48948 return NULL;
48949 }
48950
48951
48952 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48953 PyObject *resultobj = 0;
48954 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48955 int result;
48956 void *argp1 = 0 ;
48957 int res1 = 0 ;
48958 PyObject *swig_obj[1] ;
48959
48960 if (!args) SWIG_fail;
48961 swig_obj[0] = args;
48962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48963 if (!SWIG_IsOK(res1)) {
48964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48965 }
48966 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48967 {
48968 PyThreadState* __tstate = wxPyBeginAllowThreads();
48969 result = (int)(arg1)->GetCols();
48970 wxPyEndAllowThreads(__tstate);
48971 if (PyErr_Occurred()) SWIG_fail;
48972 }
48973 resultobj = SWIG_From_int(static_cast< int >(result));
48974 return resultobj;
48975 fail:
48976 return NULL;
48977 }
48978
48979
48980 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48981 PyObject *resultobj = 0;
48982 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48983 int result;
48984 void *argp1 = 0 ;
48985 int res1 = 0 ;
48986 PyObject *swig_obj[1] ;
48987
48988 if (!args) SWIG_fail;
48989 swig_obj[0] = args;
48990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48991 if (!SWIG_IsOK(res1)) {
48992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48993 }
48994 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48995 {
48996 PyThreadState* __tstate = wxPyBeginAllowThreads();
48997 result = (int)(arg1)->GetRows();
48998 wxPyEndAllowThreads(__tstate);
48999 if (PyErr_Occurred()) SWIG_fail;
49000 }
49001 resultobj = SWIG_From_int(static_cast< int >(result));
49002 return resultobj;
49003 fail:
49004 return NULL;
49005 }
49006
49007
49008 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49009 PyObject *resultobj = 0;
49010 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49011 int result;
49012 void *argp1 = 0 ;
49013 int res1 = 0 ;
49014 PyObject *swig_obj[1] ;
49015
49016 if (!args) SWIG_fail;
49017 swig_obj[0] = args;
49018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49019 if (!SWIG_IsOK(res1)) {
49020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49021 }
49022 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49023 {
49024 PyThreadState* __tstate = wxPyBeginAllowThreads();
49025 result = (int)(arg1)->GetVGap();
49026 wxPyEndAllowThreads(__tstate);
49027 if (PyErr_Occurred()) SWIG_fail;
49028 }
49029 resultobj = SWIG_From_int(static_cast< int >(result));
49030 return resultobj;
49031 fail:
49032 return NULL;
49033 }
49034
49035
49036 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49037 PyObject *resultobj = 0;
49038 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49039 int result;
49040 void *argp1 = 0 ;
49041 int res1 = 0 ;
49042 PyObject *swig_obj[1] ;
49043
49044 if (!args) SWIG_fail;
49045 swig_obj[0] = args;
49046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49047 if (!SWIG_IsOK(res1)) {
49048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49049 }
49050 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49051 {
49052 PyThreadState* __tstate = wxPyBeginAllowThreads();
49053 result = (int)(arg1)->GetHGap();
49054 wxPyEndAllowThreads(__tstate);
49055 if (PyErr_Occurred()) SWIG_fail;
49056 }
49057 resultobj = SWIG_From_int(static_cast< int >(result));
49058 return resultobj;
49059 fail:
49060 return NULL;
49061 }
49062
49063
49064 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49065 PyObject *obj;
49066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49067 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49068 return SWIG_Py_Void();
49069 }
49070
49071 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49072 return SWIG_Python_InitShadowInstance(args);
49073 }
49074
49075 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49076 PyObject *resultobj = 0;
49077 int arg1 = (int) 1 ;
49078 int arg2 = (int) 0 ;
49079 int arg3 = (int) 0 ;
49080 int arg4 = (int) 0 ;
49081 wxFlexGridSizer *result = 0 ;
49082 int val1 ;
49083 int ecode1 = 0 ;
49084 int val2 ;
49085 int ecode2 = 0 ;
49086 int val3 ;
49087 int ecode3 = 0 ;
49088 int val4 ;
49089 int ecode4 = 0 ;
49090 PyObject * obj0 = 0 ;
49091 PyObject * obj1 = 0 ;
49092 PyObject * obj2 = 0 ;
49093 PyObject * obj3 = 0 ;
49094 char * kwnames[] = {
49095 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49096 };
49097
49098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49099 if (obj0) {
49100 ecode1 = SWIG_AsVal_int(obj0, &val1);
49101 if (!SWIG_IsOK(ecode1)) {
49102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49103 }
49104 arg1 = static_cast< int >(val1);
49105 }
49106 if (obj1) {
49107 ecode2 = SWIG_AsVal_int(obj1, &val2);
49108 if (!SWIG_IsOK(ecode2)) {
49109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49110 }
49111 arg2 = static_cast< int >(val2);
49112 }
49113 if (obj2) {
49114 ecode3 = SWIG_AsVal_int(obj2, &val3);
49115 if (!SWIG_IsOK(ecode3)) {
49116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49117 }
49118 arg3 = static_cast< int >(val3);
49119 }
49120 if (obj3) {
49121 ecode4 = SWIG_AsVal_int(obj3, &val4);
49122 if (!SWIG_IsOK(ecode4)) {
49123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49124 }
49125 arg4 = static_cast< int >(val4);
49126 }
49127 {
49128 PyThreadState* __tstate = wxPyBeginAllowThreads();
49129 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49130 wxPyEndAllowThreads(__tstate);
49131 if (PyErr_Occurred()) SWIG_fail;
49132 }
49133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49134 return resultobj;
49135 fail:
49136 return NULL;
49137 }
49138
49139
49140 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49141 PyObject *resultobj = 0;
49142 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49143 size_t arg2 ;
49144 int arg3 = (int) 0 ;
49145 void *argp1 = 0 ;
49146 int res1 = 0 ;
49147 size_t val2 ;
49148 int ecode2 = 0 ;
49149 int val3 ;
49150 int ecode3 = 0 ;
49151 PyObject * obj0 = 0 ;
49152 PyObject * obj1 = 0 ;
49153 PyObject * obj2 = 0 ;
49154 char * kwnames[] = {
49155 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49156 };
49157
49158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49160 if (!SWIG_IsOK(res1)) {
49161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49162 }
49163 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49164 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49165 if (!SWIG_IsOK(ecode2)) {
49166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49167 }
49168 arg2 = static_cast< size_t >(val2);
49169 if (obj2) {
49170 ecode3 = SWIG_AsVal_int(obj2, &val3);
49171 if (!SWIG_IsOK(ecode3)) {
49172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49173 }
49174 arg3 = static_cast< int >(val3);
49175 }
49176 {
49177 PyThreadState* __tstate = wxPyBeginAllowThreads();
49178 (arg1)->AddGrowableRow(arg2,arg3);
49179 wxPyEndAllowThreads(__tstate);
49180 if (PyErr_Occurred()) SWIG_fail;
49181 }
49182 resultobj = SWIG_Py_Void();
49183 return resultobj;
49184 fail:
49185 return NULL;
49186 }
49187
49188
49189 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49190 PyObject *resultobj = 0;
49191 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49192 size_t arg2 ;
49193 void *argp1 = 0 ;
49194 int res1 = 0 ;
49195 size_t val2 ;
49196 int ecode2 = 0 ;
49197 PyObject * obj0 = 0 ;
49198 PyObject * obj1 = 0 ;
49199 char * kwnames[] = {
49200 (char *) "self",(char *) "idx", NULL
49201 };
49202
49203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49205 if (!SWIG_IsOK(res1)) {
49206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49207 }
49208 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49209 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49210 if (!SWIG_IsOK(ecode2)) {
49211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49212 }
49213 arg2 = static_cast< size_t >(val2);
49214 {
49215 PyThreadState* __tstate = wxPyBeginAllowThreads();
49216 (arg1)->RemoveGrowableRow(arg2);
49217 wxPyEndAllowThreads(__tstate);
49218 if (PyErr_Occurred()) SWIG_fail;
49219 }
49220 resultobj = SWIG_Py_Void();
49221 return resultobj;
49222 fail:
49223 return NULL;
49224 }
49225
49226
49227 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49228 PyObject *resultobj = 0;
49229 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49230 size_t arg2 ;
49231 int arg3 = (int) 0 ;
49232 void *argp1 = 0 ;
49233 int res1 = 0 ;
49234 size_t val2 ;
49235 int ecode2 = 0 ;
49236 int val3 ;
49237 int ecode3 = 0 ;
49238 PyObject * obj0 = 0 ;
49239 PyObject * obj1 = 0 ;
49240 PyObject * obj2 = 0 ;
49241 char * kwnames[] = {
49242 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49243 };
49244
49245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49247 if (!SWIG_IsOK(res1)) {
49248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49249 }
49250 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49251 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49252 if (!SWIG_IsOK(ecode2)) {
49253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49254 }
49255 arg2 = static_cast< size_t >(val2);
49256 if (obj2) {
49257 ecode3 = SWIG_AsVal_int(obj2, &val3);
49258 if (!SWIG_IsOK(ecode3)) {
49259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49260 }
49261 arg3 = static_cast< int >(val3);
49262 }
49263 {
49264 PyThreadState* __tstate = wxPyBeginAllowThreads();
49265 (arg1)->AddGrowableCol(arg2,arg3);
49266 wxPyEndAllowThreads(__tstate);
49267 if (PyErr_Occurred()) SWIG_fail;
49268 }
49269 resultobj = SWIG_Py_Void();
49270 return resultobj;
49271 fail:
49272 return NULL;
49273 }
49274
49275
49276 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49277 PyObject *resultobj = 0;
49278 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49279 size_t arg2 ;
49280 void *argp1 = 0 ;
49281 int res1 = 0 ;
49282 size_t val2 ;
49283 int ecode2 = 0 ;
49284 PyObject * obj0 = 0 ;
49285 PyObject * obj1 = 0 ;
49286 char * kwnames[] = {
49287 (char *) "self",(char *) "idx", NULL
49288 };
49289
49290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49292 if (!SWIG_IsOK(res1)) {
49293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49294 }
49295 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49296 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49297 if (!SWIG_IsOK(ecode2)) {
49298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49299 }
49300 arg2 = static_cast< size_t >(val2);
49301 {
49302 PyThreadState* __tstate = wxPyBeginAllowThreads();
49303 (arg1)->RemoveGrowableCol(arg2);
49304 wxPyEndAllowThreads(__tstate);
49305 if (PyErr_Occurred()) SWIG_fail;
49306 }
49307 resultobj = SWIG_Py_Void();
49308 return resultobj;
49309 fail:
49310 return NULL;
49311 }
49312
49313
49314 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49315 PyObject *resultobj = 0;
49316 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49317 int arg2 ;
49318 void *argp1 = 0 ;
49319 int res1 = 0 ;
49320 int val2 ;
49321 int ecode2 = 0 ;
49322 PyObject * obj0 = 0 ;
49323 PyObject * obj1 = 0 ;
49324 char * kwnames[] = {
49325 (char *) "self",(char *) "direction", NULL
49326 };
49327
49328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49330 if (!SWIG_IsOK(res1)) {
49331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49332 }
49333 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49334 ecode2 = SWIG_AsVal_int(obj1, &val2);
49335 if (!SWIG_IsOK(ecode2)) {
49336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49337 }
49338 arg2 = static_cast< int >(val2);
49339 {
49340 PyThreadState* __tstate = wxPyBeginAllowThreads();
49341 (arg1)->SetFlexibleDirection(arg2);
49342 wxPyEndAllowThreads(__tstate);
49343 if (PyErr_Occurred()) SWIG_fail;
49344 }
49345 resultobj = SWIG_Py_Void();
49346 return resultobj;
49347 fail:
49348 return NULL;
49349 }
49350
49351
49352 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49353 PyObject *resultobj = 0;
49354 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49355 int result;
49356 void *argp1 = 0 ;
49357 int res1 = 0 ;
49358 PyObject *swig_obj[1] ;
49359
49360 if (!args) SWIG_fail;
49361 swig_obj[0] = args;
49362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49363 if (!SWIG_IsOK(res1)) {
49364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49365 }
49366 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49367 {
49368 PyThreadState* __tstate = wxPyBeginAllowThreads();
49369 result = (int)(arg1)->GetFlexibleDirection();
49370 wxPyEndAllowThreads(__tstate);
49371 if (PyErr_Occurred()) SWIG_fail;
49372 }
49373 resultobj = SWIG_From_int(static_cast< int >(result));
49374 return resultobj;
49375 fail:
49376 return NULL;
49377 }
49378
49379
49380 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49381 PyObject *resultobj = 0;
49382 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49383 wxFlexSizerGrowMode arg2 ;
49384 void *argp1 = 0 ;
49385 int res1 = 0 ;
49386 int val2 ;
49387 int ecode2 = 0 ;
49388 PyObject * obj0 = 0 ;
49389 PyObject * obj1 = 0 ;
49390 char * kwnames[] = {
49391 (char *) "self",(char *) "mode", NULL
49392 };
49393
49394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49396 if (!SWIG_IsOK(res1)) {
49397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49398 }
49399 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49400 ecode2 = SWIG_AsVal_int(obj1, &val2);
49401 if (!SWIG_IsOK(ecode2)) {
49402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49403 }
49404 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49405 {
49406 PyThreadState* __tstate = wxPyBeginAllowThreads();
49407 (arg1)->SetNonFlexibleGrowMode(arg2);
49408 wxPyEndAllowThreads(__tstate);
49409 if (PyErr_Occurred()) SWIG_fail;
49410 }
49411 resultobj = SWIG_Py_Void();
49412 return resultobj;
49413 fail:
49414 return NULL;
49415 }
49416
49417
49418 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49419 PyObject *resultobj = 0;
49420 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49421 wxFlexSizerGrowMode result;
49422 void *argp1 = 0 ;
49423 int res1 = 0 ;
49424 PyObject *swig_obj[1] ;
49425
49426 if (!args) SWIG_fail;
49427 swig_obj[0] = args;
49428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49429 if (!SWIG_IsOK(res1)) {
49430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49431 }
49432 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49433 {
49434 PyThreadState* __tstate = wxPyBeginAllowThreads();
49435 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49436 wxPyEndAllowThreads(__tstate);
49437 if (PyErr_Occurred()) SWIG_fail;
49438 }
49439 resultobj = SWIG_From_int(static_cast< int >(result));
49440 return resultobj;
49441 fail:
49442 return NULL;
49443 }
49444
49445
49446 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49447 PyObject *resultobj = 0;
49448 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49449 wxArrayInt *result = 0 ;
49450 void *argp1 = 0 ;
49451 int res1 = 0 ;
49452 PyObject *swig_obj[1] ;
49453
49454 if (!args) SWIG_fail;
49455 swig_obj[0] = args;
49456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49457 if (!SWIG_IsOK(res1)) {
49458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49459 }
49460 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49461 {
49462 PyThreadState* __tstate = wxPyBeginAllowThreads();
49463 {
49464 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49465 result = (wxArrayInt *) &_result_ref;
49466 }
49467 wxPyEndAllowThreads(__tstate);
49468 if (PyErr_Occurred()) SWIG_fail;
49469 }
49470 {
49471 resultobj = PyList_New(0);
49472 size_t idx;
49473 for (idx = 0; idx < result->GetCount(); idx += 1) {
49474 PyObject* val = PyInt_FromLong( result->Item(idx) );
49475 PyList_Append(resultobj, val);
49476 Py_DECREF(val);
49477 }
49478 }
49479 return resultobj;
49480 fail:
49481 return NULL;
49482 }
49483
49484
49485 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49486 PyObject *resultobj = 0;
49487 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49488 wxArrayInt *result = 0 ;
49489 void *argp1 = 0 ;
49490 int res1 = 0 ;
49491 PyObject *swig_obj[1] ;
49492
49493 if (!args) SWIG_fail;
49494 swig_obj[0] = args;
49495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49496 if (!SWIG_IsOK(res1)) {
49497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49498 }
49499 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49500 {
49501 PyThreadState* __tstate = wxPyBeginAllowThreads();
49502 {
49503 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49504 result = (wxArrayInt *) &_result_ref;
49505 }
49506 wxPyEndAllowThreads(__tstate);
49507 if (PyErr_Occurred()) SWIG_fail;
49508 }
49509 {
49510 resultobj = PyList_New(0);
49511 size_t idx;
49512 for (idx = 0; idx < result->GetCount(); idx += 1) {
49513 PyObject* val = PyInt_FromLong( result->Item(idx) );
49514 PyList_Append(resultobj, val);
49515 Py_DECREF(val);
49516 }
49517 }
49518 return resultobj;
49519 fail:
49520 return NULL;
49521 }
49522
49523
49524 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49525 PyObject *obj;
49526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49527 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49528 return SWIG_Py_Void();
49529 }
49530
49531 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49532 return SWIG_Python_InitShadowInstance(args);
49533 }
49534
49535 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49536 PyObject *resultobj = 0;
49537 wxStdDialogButtonSizer *result = 0 ;
49538
49539 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49540 {
49541 PyThreadState* __tstate = wxPyBeginAllowThreads();
49542 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49543 wxPyEndAllowThreads(__tstate);
49544 if (PyErr_Occurred()) SWIG_fail;
49545 }
49546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49547 return resultobj;
49548 fail:
49549 return NULL;
49550 }
49551
49552
49553 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49554 PyObject *resultobj = 0;
49555 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49556 wxButton *arg2 = (wxButton *) 0 ;
49557 void *argp1 = 0 ;
49558 int res1 = 0 ;
49559 void *argp2 = 0 ;
49560 int res2 = 0 ;
49561 PyObject * obj0 = 0 ;
49562 PyObject * obj1 = 0 ;
49563 char * kwnames[] = {
49564 (char *) "self",(char *) "button", NULL
49565 };
49566
49567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49569 if (!SWIG_IsOK(res1)) {
49570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49571 }
49572 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49574 if (!SWIG_IsOK(res2)) {
49575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49576 }
49577 arg2 = reinterpret_cast< wxButton * >(argp2);
49578 {
49579 PyThreadState* __tstate = wxPyBeginAllowThreads();
49580 (arg1)->AddButton(arg2);
49581 wxPyEndAllowThreads(__tstate);
49582 if (PyErr_Occurred()) SWIG_fail;
49583 }
49584 resultobj = SWIG_Py_Void();
49585 return resultobj;
49586 fail:
49587 return NULL;
49588 }
49589
49590
49591 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49592 PyObject *resultobj = 0;
49593 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49594 void *argp1 = 0 ;
49595 int res1 = 0 ;
49596 PyObject *swig_obj[1] ;
49597
49598 if (!args) SWIG_fail;
49599 swig_obj[0] = args;
49600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49601 if (!SWIG_IsOK(res1)) {
49602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49603 }
49604 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49605 {
49606 PyThreadState* __tstate = wxPyBeginAllowThreads();
49607 (arg1)->Realize();
49608 wxPyEndAllowThreads(__tstate);
49609 if (PyErr_Occurred()) SWIG_fail;
49610 }
49611 resultobj = SWIG_Py_Void();
49612 return resultobj;
49613 fail:
49614 return NULL;
49615 }
49616
49617
49618 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49619 PyObject *resultobj = 0;
49620 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49621 wxButton *arg2 = (wxButton *) 0 ;
49622 void *argp1 = 0 ;
49623 int res1 = 0 ;
49624 void *argp2 = 0 ;
49625 int res2 = 0 ;
49626 PyObject * obj0 = 0 ;
49627 PyObject * obj1 = 0 ;
49628 char * kwnames[] = {
49629 (char *) "self",(char *) "button", NULL
49630 };
49631
49632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49634 if (!SWIG_IsOK(res1)) {
49635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49636 }
49637 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49639 if (!SWIG_IsOK(res2)) {
49640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49641 }
49642 arg2 = reinterpret_cast< wxButton * >(argp2);
49643 {
49644 PyThreadState* __tstate = wxPyBeginAllowThreads();
49645 (arg1)->SetAffirmativeButton(arg2);
49646 wxPyEndAllowThreads(__tstate);
49647 if (PyErr_Occurred()) SWIG_fail;
49648 }
49649 resultobj = SWIG_Py_Void();
49650 return resultobj;
49651 fail:
49652 return NULL;
49653 }
49654
49655
49656 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49657 PyObject *resultobj = 0;
49658 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49659 wxButton *arg2 = (wxButton *) 0 ;
49660 void *argp1 = 0 ;
49661 int res1 = 0 ;
49662 void *argp2 = 0 ;
49663 int res2 = 0 ;
49664 PyObject * obj0 = 0 ;
49665 PyObject * obj1 = 0 ;
49666 char * kwnames[] = {
49667 (char *) "self",(char *) "button", NULL
49668 };
49669
49670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49672 if (!SWIG_IsOK(res1)) {
49673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49674 }
49675 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49677 if (!SWIG_IsOK(res2)) {
49678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49679 }
49680 arg2 = reinterpret_cast< wxButton * >(argp2);
49681 {
49682 PyThreadState* __tstate = wxPyBeginAllowThreads();
49683 (arg1)->SetNegativeButton(arg2);
49684 wxPyEndAllowThreads(__tstate);
49685 if (PyErr_Occurred()) SWIG_fail;
49686 }
49687 resultobj = SWIG_Py_Void();
49688 return resultobj;
49689 fail:
49690 return NULL;
49691 }
49692
49693
49694 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49695 PyObject *resultobj = 0;
49696 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49697 wxButton *arg2 = (wxButton *) 0 ;
49698 void *argp1 = 0 ;
49699 int res1 = 0 ;
49700 void *argp2 = 0 ;
49701 int res2 = 0 ;
49702 PyObject * obj0 = 0 ;
49703 PyObject * obj1 = 0 ;
49704 char * kwnames[] = {
49705 (char *) "self",(char *) "button", NULL
49706 };
49707
49708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49710 if (!SWIG_IsOK(res1)) {
49711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49712 }
49713 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49715 if (!SWIG_IsOK(res2)) {
49716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49717 }
49718 arg2 = reinterpret_cast< wxButton * >(argp2);
49719 {
49720 PyThreadState* __tstate = wxPyBeginAllowThreads();
49721 (arg1)->SetCancelButton(arg2);
49722 wxPyEndAllowThreads(__tstate);
49723 if (PyErr_Occurred()) SWIG_fail;
49724 }
49725 resultobj = SWIG_Py_Void();
49726 return resultobj;
49727 fail:
49728 return NULL;
49729 }
49730
49731
49732 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49733 PyObject *resultobj = 0;
49734 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49735 wxButton *result = 0 ;
49736 void *argp1 = 0 ;
49737 int res1 = 0 ;
49738 PyObject *swig_obj[1] ;
49739
49740 if (!args) SWIG_fail;
49741 swig_obj[0] = args;
49742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49743 if (!SWIG_IsOK(res1)) {
49744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49745 }
49746 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49747 {
49748 PyThreadState* __tstate = wxPyBeginAllowThreads();
49749 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49750 wxPyEndAllowThreads(__tstate);
49751 if (PyErr_Occurred()) SWIG_fail;
49752 }
49753 {
49754 resultobj = wxPyMake_wxObject(result, (bool)0);
49755 }
49756 return resultobj;
49757 fail:
49758 return NULL;
49759 }
49760
49761
49762 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49763 PyObject *resultobj = 0;
49764 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49765 wxButton *result = 0 ;
49766 void *argp1 = 0 ;
49767 int res1 = 0 ;
49768 PyObject *swig_obj[1] ;
49769
49770 if (!args) SWIG_fail;
49771 swig_obj[0] = args;
49772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49773 if (!SWIG_IsOK(res1)) {
49774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49775 }
49776 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49777 {
49778 PyThreadState* __tstate = wxPyBeginAllowThreads();
49779 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49780 wxPyEndAllowThreads(__tstate);
49781 if (PyErr_Occurred()) SWIG_fail;
49782 }
49783 {
49784 resultobj = wxPyMake_wxObject(result, (bool)0);
49785 }
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49793 PyObject *resultobj = 0;
49794 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49795 wxButton *result = 0 ;
49796 void *argp1 = 0 ;
49797 int res1 = 0 ;
49798 PyObject *swig_obj[1] ;
49799
49800 if (!args) SWIG_fail;
49801 swig_obj[0] = args;
49802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49803 if (!SWIG_IsOK(res1)) {
49804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49805 }
49806 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49807 {
49808 PyThreadState* __tstate = wxPyBeginAllowThreads();
49809 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49810 wxPyEndAllowThreads(__tstate);
49811 if (PyErr_Occurred()) SWIG_fail;
49812 }
49813 {
49814 resultobj = wxPyMake_wxObject(result, (bool)0);
49815 }
49816 return resultobj;
49817 fail:
49818 return NULL;
49819 }
49820
49821
49822 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49823 PyObject *resultobj = 0;
49824 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49825 wxButton *result = 0 ;
49826 void *argp1 = 0 ;
49827 int res1 = 0 ;
49828 PyObject *swig_obj[1] ;
49829
49830 if (!args) SWIG_fail;
49831 swig_obj[0] = args;
49832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49833 if (!SWIG_IsOK(res1)) {
49834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49835 }
49836 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49837 {
49838 PyThreadState* __tstate = wxPyBeginAllowThreads();
49839 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49840 wxPyEndAllowThreads(__tstate);
49841 if (PyErr_Occurred()) SWIG_fail;
49842 }
49843 {
49844 resultobj = wxPyMake_wxObject(result, (bool)0);
49845 }
49846 return resultobj;
49847 fail:
49848 return NULL;
49849 }
49850
49851
49852 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49853 PyObject *resultobj = 0;
49854 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49855 wxButton *result = 0 ;
49856 void *argp1 = 0 ;
49857 int res1 = 0 ;
49858 PyObject *swig_obj[1] ;
49859
49860 if (!args) SWIG_fail;
49861 swig_obj[0] = args;
49862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49863 if (!SWIG_IsOK(res1)) {
49864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49865 }
49866 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49867 {
49868 PyThreadState* __tstate = wxPyBeginAllowThreads();
49869 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49870 wxPyEndAllowThreads(__tstate);
49871 if (PyErr_Occurred()) SWIG_fail;
49872 }
49873 {
49874 resultobj = wxPyMake_wxObject(result, (bool)0);
49875 }
49876 return resultobj;
49877 fail:
49878 return NULL;
49879 }
49880
49881
49882 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49883 PyObject *obj;
49884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49885 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49886 return SWIG_Py_Void();
49887 }
49888
49889 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49890 return SWIG_Python_InitShadowInstance(args);
49891 }
49892
49893 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49894 PyObject *resultobj = 0;
49895 int arg1 = (int) 0 ;
49896 int arg2 = (int) 0 ;
49897 wxGBPosition *result = 0 ;
49898 int val1 ;
49899 int ecode1 = 0 ;
49900 int val2 ;
49901 int ecode2 = 0 ;
49902 PyObject * obj0 = 0 ;
49903 PyObject * obj1 = 0 ;
49904 char * kwnames[] = {
49905 (char *) "row",(char *) "col", NULL
49906 };
49907
49908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49909 if (obj0) {
49910 ecode1 = SWIG_AsVal_int(obj0, &val1);
49911 if (!SWIG_IsOK(ecode1)) {
49912 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49913 }
49914 arg1 = static_cast< int >(val1);
49915 }
49916 if (obj1) {
49917 ecode2 = SWIG_AsVal_int(obj1, &val2);
49918 if (!SWIG_IsOK(ecode2)) {
49919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49920 }
49921 arg2 = static_cast< int >(val2);
49922 }
49923 {
49924 PyThreadState* __tstate = wxPyBeginAllowThreads();
49925 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49926 wxPyEndAllowThreads(__tstate);
49927 if (PyErr_Occurred()) SWIG_fail;
49928 }
49929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49930 return resultobj;
49931 fail:
49932 return NULL;
49933 }
49934
49935
49936 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49937 PyObject *resultobj = 0;
49938 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49939 void *argp1 = 0 ;
49940 int res1 = 0 ;
49941 PyObject *swig_obj[1] ;
49942
49943 if (!args) SWIG_fail;
49944 swig_obj[0] = args;
49945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49946 if (!SWIG_IsOK(res1)) {
49947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49948 }
49949 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49950 {
49951 PyThreadState* __tstate = wxPyBeginAllowThreads();
49952 delete arg1;
49953
49954 wxPyEndAllowThreads(__tstate);
49955 if (PyErr_Occurred()) SWIG_fail;
49956 }
49957 resultobj = SWIG_Py_Void();
49958 return resultobj;
49959 fail:
49960 return NULL;
49961 }
49962
49963
49964 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49965 PyObject *resultobj = 0;
49966 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49967 int result;
49968 void *argp1 = 0 ;
49969 int res1 = 0 ;
49970 PyObject *swig_obj[1] ;
49971
49972 if (!args) SWIG_fail;
49973 swig_obj[0] = args;
49974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49975 if (!SWIG_IsOK(res1)) {
49976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49977 }
49978 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49979 {
49980 PyThreadState* __tstate = wxPyBeginAllowThreads();
49981 result = (int)((wxGBPosition const *)arg1)->GetRow();
49982 wxPyEndAllowThreads(__tstate);
49983 if (PyErr_Occurred()) SWIG_fail;
49984 }
49985 resultobj = SWIG_From_int(static_cast< int >(result));
49986 return resultobj;
49987 fail:
49988 return NULL;
49989 }
49990
49991
49992 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49993 PyObject *resultobj = 0;
49994 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49995 int result;
49996 void *argp1 = 0 ;
49997 int res1 = 0 ;
49998 PyObject *swig_obj[1] ;
49999
50000 if (!args) SWIG_fail;
50001 swig_obj[0] = args;
50002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50003 if (!SWIG_IsOK(res1)) {
50004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50005 }
50006 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50007 {
50008 PyThreadState* __tstate = wxPyBeginAllowThreads();
50009 result = (int)((wxGBPosition const *)arg1)->GetCol();
50010 wxPyEndAllowThreads(__tstate);
50011 if (PyErr_Occurred()) SWIG_fail;
50012 }
50013 resultobj = SWIG_From_int(static_cast< int >(result));
50014 return resultobj;
50015 fail:
50016 return NULL;
50017 }
50018
50019
50020 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50021 PyObject *resultobj = 0;
50022 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50023 int arg2 ;
50024 void *argp1 = 0 ;
50025 int res1 = 0 ;
50026 int val2 ;
50027 int ecode2 = 0 ;
50028 PyObject * obj0 = 0 ;
50029 PyObject * obj1 = 0 ;
50030 char * kwnames[] = {
50031 (char *) "self",(char *) "row", NULL
50032 };
50033
50034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50036 if (!SWIG_IsOK(res1)) {
50037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50038 }
50039 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50040 ecode2 = SWIG_AsVal_int(obj1, &val2);
50041 if (!SWIG_IsOK(ecode2)) {
50042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50043 }
50044 arg2 = static_cast< int >(val2);
50045 {
50046 PyThreadState* __tstate = wxPyBeginAllowThreads();
50047 (arg1)->SetRow(arg2);
50048 wxPyEndAllowThreads(__tstate);
50049 if (PyErr_Occurred()) SWIG_fail;
50050 }
50051 resultobj = SWIG_Py_Void();
50052 return resultobj;
50053 fail:
50054 return NULL;
50055 }
50056
50057
50058 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50059 PyObject *resultobj = 0;
50060 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50061 int arg2 ;
50062 void *argp1 = 0 ;
50063 int res1 = 0 ;
50064 int val2 ;
50065 int ecode2 = 0 ;
50066 PyObject * obj0 = 0 ;
50067 PyObject * obj1 = 0 ;
50068 char * kwnames[] = {
50069 (char *) "self",(char *) "col", NULL
50070 };
50071
50072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50074 if (!SWIG_IsOK(res1)) {
50075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50076 }
50077 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50078 ecode2 = SWIG_AsVal_int(obj1, &val2);
50079 if (!SWIG_IsOK(ecode2)) {
50080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50081 }
50082 arg2 = static_cast< int >(val2);
50083 {
50084 PyThreadState* __tstate = wxPyBeginAllowThreads();
50085 (arg1)->SetCol(arg2);
50086 wxPyEndAllowThreads(__tstate);
50087 if (PyErr_Occurred()) SWIG_fail;
50088 }
50089 resultobj = SWIG_Py_Void();
50090 return resultobj;
50091 fail:
50092 return NULL;
50093 }
50094
50095
50096 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50097 PyObject *resultobj = 0;
50098 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50099 PyObject *arg2 = (PyObject *) 0 ;
50100 bool result;
50101 void *argp1 = 0 ;
50102 int res1 = 0 ;
50103 PyObject * obj0 = 0 ;
50104 PyObject * obj1 = 0 ;
50105 char * kwnames[] = {
50106 (char *) "self",(char *) "other", NULL
50107 };
50108
50109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50111 if (!SWIG_IsOK(res1)) {
50112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50113 }
50114 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50115 arg2 = obj1;
50116 {
50117 result = (bool)wxGBPosition___eq__(arg1,arg2);
50118 if (PyErr_Occurred()) SWIG_fail;
50119 }
50120 {
50121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50122 }
50123 return resultobj;
50124 fail:
50125 return NULL;
50126 }
50127
50128
50129 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50130 PyObject *resultobj = 0;
50131 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50132 PyObject *arg2 = (PyObject *) 0 ;
50133 bool result;
50134 void *argp1 = 0 ;
50135 int res1 = 0 ;
50136 PyObject * obj0 = 0 ;
50137 PyObject * obj1 = 0 ;
50138 char * kwnames[] = {
50139 (char *) "self",(char *) "other", NULL
50140 };
50141
50142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50144 if (!SWIG_IsOK(res1)) {
50145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50146 }
50147 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50148 arg2 = obj1;
50149 {
50150 result = (bool)wxGBPosition___ne__(arg1,arg2);
50151 if (PyErr_Occurred()) SWIG_fail;
50152 }
50153 {
50154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50155 }
50156 return resultobj;
50157 fail:
50158 return NULL;
50159 }
50160
50161
50162 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50163 PyObject *resultobj = 0;
50164 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50165 int arg2 = (int) 0 ;
50166 int arg3 = (int) 0 ;
50167 void *argp1 = 0 ;
50168 int res1 = 0 ;
50169 int val2 ;
50170 int ecode2 = 0 ;
50171 int val3 ;
50172 int ecode3 = 0 ;
50173 PyObject * obj0 = 0 ;
50174 PyObject * obj1 = 0 ;
50175 PyObject * obj2 = 0 ;
50176 char * kwnames[] = {
50177 (char *) "self",(char *) "row",(char *) "col", NULL
50178 };
50179
50180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50182 if (!SWIG_IsOK(res1)) {
50183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50184 }
50185 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50186 if (obj1) {
50187 ecode2 = SWIG_AsVal_int(obj1, &val2);
50188 if (!SWIG_IsOK(ecode2)) {
50189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50190 }
50191 arg2 = static_cast< int >(val2);
50192 }
50193 if (obj2) {
50194 ecode3 = SWIG_AsVal_int(obj2, &val3);
50195 if (!SWIG_IsOK(ecode3)) {
50196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50197 }
50198 arg3 = static_cast< int >(val3);
50199 }
50200 {
50201 PyThreadState* __tstate = wxPyBeginAllowThreads();
50202 wxGBPosition_Set(arg1,arg2,arg3);
50203 wxPyEndAllowThreads(__tstate);
50204 if (PyErr_Occurred()) SWIG_fail;
50205 }
50206 resultobj = SWIG_Py_Void();
50207 return resultobj;
50208 fail:
50209 return NULL;
50210 }
50211
50212
50213 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50214 PyObject *resultobj = 0;
50215 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50216 PyObject *result = 0 ;
50217 void *argp1 = 0 ;
50218 int res1 = 0 ;
50219 PyObject *swig_obj[1] ;
50220
50221 if (!args) SWIG_fail;
50222 swig_obj[0] = args;
50223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50224 if (!SWIG_IsOK(res1)) {
50225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50226 }
50227 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50228 {
50229 PyThreadState* __tstate = wxPyBeginAllowThreads();
50230 result = (PyObject *)wxGBPosition_Get(arg1);
50231 wxPyEndAllowThreads(__tstate);
50232 if (PyErr_Occurred()) SWIG_fail;
50233 }
50234 resultobj = result;
50235 return resultobj;
50236 fail:
50237 return NULL;
50238 }
50239
50240
50241 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50242 PyObject *obj;
50243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50244 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50245 return SWIG_Py_Void();
50246 }
50247
50248 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50249 return SWIG_Python_InitShadowInstance(args);
50250 }
50251
50252 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50253 PyObject *resultobj = 0;
50254 int arg1 = (int) 1 ;
50255 int arg2 = (int) 1 ;
50256 wxGBSpan *result = 0 ;
50257 int val1 ;
50258 int ecode1 = 0 ;
50259 int val2 ;
50260 int ecode2 = 0 ;
50261 PyObject * obj0 = 0 ;
50262 PyObject * obj1 = 0 ;
50263 char * kwnames[] = {
50264 (char *) "rowspan",(char *) "colspan", NULL
50265 };
50266
50267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50268 if (obj0) {
50269 ecode1 = SWIG_AsVal_int(obj0, &val1);
50270 if (!SWIG_IsOK(ecode1)) {
50271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50272 }
50273 arg1 = static_cast< int >(val1);
50274 }
50275 if (obj1) {
50276 ecode2 = SWIG_AsVal_int(obj1, &val2);
50277 if (!SWIG_IsOK(ecode2)) {
50278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50279 }
50280 arg2 = static_cast< int >(val2);
50281 }
50282 {
50283 PyThreadState* __tstate = wxPyBeginAllowThreads();
50284 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50285 wxPyEndAllowThreads(__tstate);
50286 if (PyErr_Occurred()) SWIG_fail;
50287 }
50288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50289 return resultobj;
50290 fail:
50291 return NULL;
50292 }
50293
50294
50295 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50296 PyObject *resultobj = 0;
50297 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50298 void *argp1 = 0 ;
50299 int res1 = 0 ;
50300 PyObject *swig_obj[1] ;
50301
50302 if (!args) SWIG_fail;
50303 swig_obj[0] = args;
50304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50305 if (!SWIG_IsOK(res1)) {
50306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50307 }
50308 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50309 {
50310 PyThreadState* __tstate = wxPyBeginAllowThreads();
50311 delete arg1;
50312
50313 wxPyEndAllowThreads(__tstate);
50314 if (PyErr_Occurred()) SWIG_fail;
50315 }
50316 resultobj = SWIG_Py_Void();
50317 return resultobj;
50318 fail:
50319 return NULL;
50320 }
50321
50322
50323 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50324 PyObject *resultobj = 0;
50325 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50326 int result;
50327 void *argp1 = 0 ;
50328 int res1 = 0 ;
50329 PyObject *swig_obj[1] ;
50330
50331 if (!args) SWIG_fail;
50332 swig_obj[0] = args;
50333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50334 if (!SWIG_IsOK(res1)) {
50335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50336 }
50337 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50338 {
50339 PyThreadState* __tstate = wxPyBeginAllowThreads();
50340 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50341 wxPyEndAllowThreads(__tstate);
50342 if (PyErr_Occurred()) SWIG_fail;
50343 }
50344 resultobj = SWIG_From_int(static_cast< int >(result));
50345 return resultobj;
50346 fail:
50347 return NULL;
50348 }
50349
50350
50351 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50352 PyObject *resultobj = 0;
50353 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50354 int result;
50355 void *argp1 = 0 ;
50356 int res1 = 0 ;
50357 PyObject *swig_obj[1] ;
50358
50359 if (!args) SWIG_fail;
50360 swig_obj[0] = args;
50361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50362 if (!SWIG_IsOK(res1)) {
50363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50364 }
50365 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50366 {
50367 PyThreadState* __tstate = wxPyBeginAllowThreads();
50368 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50369 wxPyEndAllowThreads(__tstate);
50370 if (PyErr_Occurred()) SWIG_fail;
50371 }
50372 resultobj = SWIG_From_int(static_cast< int >(result));
50373 return resultobj;
50374 fail:
50375 return NULL;
50376 }
50377
50378
50379 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50380 PyObject *resultobj = 0;
50381 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50382 int arg2 ;
50383 void *argp1 = 0 ;
50384 int res1 = 0 ;
50385 int val2 ;
50386 int ecode2 = 0 ;
50387 PyObject * obj0 = 0 ;
50388 PyObject * obj1 = 0 ;
50389 char * kwnames[] = {
50390 (char *) "self",(char *) "rowspan", NULL
50391 };
50392
50393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50395 if (!SWIG_IsOK(res1)) {
50396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50397 }
50398 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50399 ecode2 = SWIG_AsVal_int(obj1, &val2);
50400 if (!SWIG_IsOK(ecode2)) {
50401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50402 }
50403 arg2 = static_cast< int >(val2);
50404 {
50405 PyThreadState* __tstate = wxPyBeginAllowThreads();
50406 (arg1)->SetRowspan(arg2);
50407 wxPyEndAllowThreads(__tstate);
50408 if (PyErr_Occurred()) SWIG_fail;
50409 }
50410 resultobj = SWIG_Py_Void();
50411 return resultobj;
50412 fail:
50413 return NULL;
50414 }
50415
50416
50417 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50418 PyObject *resultobj = 0;
50419 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50420 int arg2 ;
50421 void *argp1 = 0 ;
50422 int res1 = 0 ;
50423 int val2 ;
50424 int ecode2 = 0 ;
50425 PyObject * obj0 = 0 ;
50426 PyObject * obj1 = 0 ;
50427 char * kwnames[] = {
50428 (char *) "self",(char *) "colspan", NULL
50429 };
50430
50431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50433 if (!SWIG_IsOK(res1)) {
50434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50435 }
50436 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50437 ecode2 = SWIG_AsVal_int(obj1, &val2);
50438 if (!SWIG_IsOK(ecode2)) {
50439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50440 }
50441 arg2 = static_cast< int >(val2);
50442 {
50443 PyThreadState* __tstate = wxPyBeginAllowThreads();
50444 (arg1)->SetColspan(arg2);
50445 wxPyEndAllowThreads(__tstate);
50446 if (PyErr_Occurred()) SWIG_fail;
50447 }
50448 resultobj = SWIG_Py_Void();
50449 return resultobj;
50450 fail:
50451 return NULL;
50452 }
50453
50454
50455 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50456 PyObject *resultobj = 0;
50457 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50458 PyObject *arg2 = (PyObject *) 0 ;
50459 bool result;
50460 void *argp1 = 0 ;
50461 int res1 = 0 ;
50462 PyObject * obj0 = 0 ;
50463 PyObject * obj1 = 0 ;
50464 char * kwnames[] = {
50465 (char *) "self",(char *) "other", NULL
50466 };
50467
50468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50470 if (!SWIG_IsOK(res1)) {
50471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50472 }
50473 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50474 arg2 = obj1;
50475 {
50476 result = (bool)wxGBSpan___eq__(arg1,arg2);
50477 if (PyErr_Occurred()) SWIG_fail;
50478 }
50479 {
50480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50481 }
50482 return resultobj;
50483 fail:
50484 return NULL;
50485 }
50486
50487
50488 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50489 PyObject *resultobj = 0;
50490 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50491 PyObject *arg2 = (PyObject *) 0 ;
50492 bool result;
50493 void *argp1 = 0 ;
50494 int res1 = 0 ;
50495 PyObject * obj0 = 0 ;
50496 PyObject * obj1 = 0 ;
50497 char * kwnames[] = {
50498 (char *) "self",(char *) "other", NULL
50499 };
50500
50501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50503 if (!SWIG_IsOK(res1)) {
50504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50505 }
50506 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50507 arg2 = obj1;
50508 {
50509 result = (bool)wxGBSpan___ne__(arg1,arg2);
50510 if (PyErr_Occurred()) SWIG_fail;
50511 }
50512 {
50513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50514 }
50515 return resultobj;
50516 fail:
50517 return NULL;
50518 }
50519
50520
50521 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50522 PyObject *resultobj = 0;
50523 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50524 int arg2 = (int) 1 ;
50525 int arg3 = (int) 1 ;
50526 void *argp1 = 0 ;
50527 int res1 = 0 ;
50528 int val2 ;
50529 int ecode2 = 0 ;
50530 int val3 ;
50531 int ecode3 = 0 ;
50532 PyObject * obj0 = 0 ;
50533 PyObject * obj1 = 0 ;
50534 PyObject * obj2 = 0 ;
50535 char * kwnames[] = {
50536 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50537 };
50538
50539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50541 if (!SWIG_IsOK(res1)) {
50542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50543 }
50544 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50545 if (obj1) {
50546 ecode2 = SWIG_AsVal_int(obj1, &val2);
50547 if (!SWIG_IsOK(ecode2)) {
50548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50549 }
50550 arg2 = static_cast< int >(val2);
50551 }
50552 if (obj2) {
50553 ecode3 = SWIG_AsVal_int(obj2, &val3);
50554 if (!SWIG_IsOK(ecode3)) {
50555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50556 }
50557 arg3 = static_cast< int >(val3);
50558 }
50559 {
50560 PyThreadState* __tstate = wxPyBeginAllowThreads();
50561 wxGBSpan_Set(arg1,arg2,arg3);
50562 wxPyEndAllowThreads(__tstate);
50563 if (PyErr_Occurred()) SWIG_fail;
50564 }
50565 resultobj = SWIG_Py_Void();
50566 return resultobj;
50567 fail:
50568 return NULL;
50569 }
50570
50571
50572 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50573 PyObject *resultobj = 0;
50574 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50575 PyObject *result = 0 ;
50576 void *argp1 = 0 ;
50577 int res1 = 0 ;
50578 PyObject *swig_obj[1] ;
50579
50580 if (!args) SWIG_fail;
50581 swig_obj[0] = args;
50582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50583 if (!SWIG_IsOK(res1)) {
50584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50585 }
50586 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50587 {
50588 PyThreadState* __tstate = wxPyBeginAllowThreads();
50589 result = (PyObject *)wxGBSpan_Get(arg1);
50590 wxPyEndAllowThreads(__tstate);
50591 if (PyErr_Occurred()) SWIG_fail;
50592 }
50593 resultobj = result;
50594 return resultobj;
50595 fail:
50596 return NULL;
50597 }
50598
50599
50600 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50601 PyObject *obj;
50602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50603 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50604 return SWIG_Py_Void();
50605 }
50606
50607 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50608 return SWIG_Python_InitShadowInstance(args);
50609 }
50610
50611 SWIGINTERN int DefaultSpan_set(PyObject *) {
50612 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50613 return 1;
50614 }
50615
50616
50617 SWIGINTERN PyObject *DefaultSpan_get(void) {
50618 PyObject *pyobj = 0;
50619
50620 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50621 return pyobj;
50622 }
50623
50624
50625 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50626 PyObject *resultobj = 0;
50627 wxGBSizerItem *result = 0 ;
50628
50629 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50630 {
50631 PyThreadState* __tstate = wxPyBeginAllowThreads();
50632 result = (wxGBSizerItem *)new wxGBSizerItem();
50633 wxPyEndAllowThreads(__tstate);
50634 if (PyErr_Occurred()) SWIG_fail;
50635 }
50636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50637 return resultobj;
50638 fail:
50639 return NULL;
50640 }
50641
50642
50643 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50644 PyObject *resultobj = 0;
50645 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50646 void *argp1 = 0 ;
50647 int res1 = 0 ;
50648 PyObject *swig_obj[1] ;
50649
50650 if (!args) SWIG_fail;
50651 swig_obj[0] = args;
50652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50653 if (!SWIG_IsOK(res1)) {
50654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50655 }
50656 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50657 {
50658 PyThreadState* __tstate = wxPyBeginAllowThreads();
50659 delete arg1;
50660
50661 wxPyEndAllowThreads(__tstate);
50662 if (PyErr_Occurred()) SWIG_fail;
50663 }
50664 resultobj = SWIG_Py_Void();
50665 return resultobj;
50666 fail:
50667 return NULL;
50668 }
50669
50670
50671 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50672 PyObject *resultobj = 0;
50673 wxWindow *arg1 = (wxWindow *) 0 ;
50674 wxGBPosition *arg2 = 0 ;
50675 wxGBSpan *arg3 = 0 ;
50676 int arg4 ;
50677 int arg5 ;
50678 PyObject *arg6 = (PyObject *) NULL ;
50679 wxGBSizerItem *result = 0 ;
50680 void *argp1 = 0 ;
50681 int res1 = 0 ;
50682 wxGBPosition temp2 ;
50683 wxGBSpan temp3 ;
50684 int val4 ;
50685 int ecode4 = 0 ;
50686 int val5 ;
50687 int ecode5 = 0 ;
50688 PyObject * obj0 = 0 ;
50689 PyObject * obj1 = 0 ;
50690 PyObject * obj2 = 0 ;
50691 PyObject * obj3 = 0 ;
50692 PyObject * obj4 = 0 ;
50693 PyObject * obj5 = 0 ;
50694 char * kwnames[] = {
50695 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50696 };
50697
50698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50700 if (!SWIG_IsOK(res1)) {
50701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50702 }
50703 arg1 = reinterpret_cast< wxWindow * >(argp1);
50704 {
50705 arg2 = &temp2;
50706 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50707 }
50708 {
50709 arg3 = &temp3;
50710 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50711 }
50712 ecode4 = SWIG_AsVal_int(obj3, &val4);
50713 if (!SWIG_IsOK(ecode4)) {
50714 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50715 }
50716 arg4 = static_cast< int >(val4);
50717 ecode5 = SWIG_AsVal_int(obj4, &val5);
50718 if (!SWIG_IsOK(ecode5)) {
50719 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50720 }
50721 arg5 = static_cast< int >(val5);
50722 if (obj5) {
50723 arg6 = obj5;
50724 }
50725 {
50726 PyThreadState* __tstate = wxPyBeginAllowThreads();
50727 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50728 wxPyEndAllowThreads(__tstate);
50729 if (PyErr_Occurred()) SWIG_fail;
50730 }
50731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50732 return resultobj;
50733 fail:
50734 return NULL;
50735 }
50736
50737
50738 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50739 PyObject *resultobj = 0;
50740 wxSizer *arg1 = (wxSizer *) 0 ;
50741 wxGBPosition *arg2 = 0 ;
50742 wxGBSpan *arg3 = 0 ;
50743 int arg4 ;
50744 int arg5 ;
50745 PyObject *arg6 = (PyObject *) NULL ;
50746 wxGBSizerItem *result = 0 ;
50747 int res1 = 0 ;
50748 wxGBPosition temp2 ;
50749 wxGBSpan temp3 ;
50750 int val4 ;
50751 int ecode4 = 0 ;
50752 int val5 ;
50753 int ecode5 = 0 ;
50754 PyObject * obj0 = 0 ;
50755 PyObject * obj1 = 0 ;
50756 PyObject * obj2 = 0 ;
50757 PyObject * obj3 = 0 ;
50758 PyObject * obj4 = 0 ;
50759 PyObject * obj5 = 0 ;
50760 char * kwnames[] = {
50761 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50762 };
50763
50764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50765 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50766 if (!SWIG_IsOK(res1)) {
50767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50768 }
50769 {
50770 arg2 = &temp2;
50771 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50772 }
50773 {
50774 arg3 = &temp3;
50775 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50776 }
50777 ecode4 = SWIG_AsVal_int(obj3, &val4);
50778 if (!SWIG_IsOK(ecode4)) {
50779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50780 }
50781 arg4 = static_cast< int >(val4);
50782 ecode5 = SWIG_AsVal_int(obj4, &val5);
50783 if (!SWIG_IsOK(ecode5)) {
50784 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50785 }
50786 arg5 = static_cast< int >(val5);
50787 if (obj5) {
50788 arg6 = obj5;
50789 }
50790 {
50791 PyThreadState* __tstate = wxPyBeginAllowThreads();
50792 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50793 wxPyEndAllowThreads(__tstate);
50794 if (PyErr_Occurred()) SWIG_fail;
50795 }
50796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50797 return resultobj;
50798 fail:
50799 return NULL;
50800 }
50801
50802
50803 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50804 PyObject *resultobj = 0;
50805 int arg1 ;
50806 int arg2 ;
50807 wxGBPosition *arg3 = 0 ;
50808 wxGBSpan *arg4 = 0 ;
50809 int arg5 ;
50810 int arg6 ;
50811 PyObject *arg7 = (PyObject *) NULL ;
50812 wxGBSizerItem *result = 0 ;
50813 int val1 ;
50814 int ecode1 = 0 ;
50815 int val2 ;
50816 int ecode2 = 0 ;
50817 wxGBPosition temp3 ;
50818 wxGBSpan temp4 ;
50819 int val5 ;
50820 int ecode5 = 0 ;
50821 int val6 ;
50822 int ecode6 = 0 ;
50823 PyObject * obj0 = 0 ;
50824 PyObject * obj1 = 0 ;
50825 PyObject * obj2 = 0 ;
50826 PyObject * obj3 = 0 ;
50827 PyObject * obj4 = 0 ;
50828 PyObject * obj5 = 0 ;
50829 PyObject * obj6 = 0 ;
50830 char * kwnames[] = {
50831 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50832 };
50833
50834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50835 ecode1 = SWIG_AsVal_int(obj0, &val1);
50836 if (!SWIG_IsOK(ecode1)) {
50837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50838 }
50839 arg1 = static_cast< int >(val1);
50840 ecode2 = SWIG_AsVal_int(obj1, &val2);
50841 if (!SWIG_IsOK(ecode2)) {
50842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50843 }
50844 arg2 = static_cast< int >(val2);
50845 {
50846 arg3 = &temp3;
50847 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50848 }
50849 {
50850 arg4 = &temp4;
50851 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50852 }
50853 ecode5 = SWIG_AsVal_int(obj4, &val5);
50854 if (!SWIG_IsOK(ecode5)) {
50855 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50856 }
50857 arg5 = static_cast< int >(val5);
50858 ecode6 = SWIG_AsVal_int(obj5, &val6);
50859 if (!SWIG_IsOK(ecode6)) {
50860 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50861 }
50862 arg6 = static_cast< int >(val6);
50863 if (obj6) {
50864 arg7 = obj6;
50865 }
50866 {
50867 PyThreadState* __tstate = wxPyBeginAllowThreads();
50868 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50869 wxPyEndAllowThreads(__tstate);
50870 if (PyErr_Occurred()) SWIG_fail;
50871 }
50872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50873 return resultobj;
50874 fail:
50875 return NULL;
50876 }
50877
50878
50879 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50880 PyObject *resultobj = 0;
50881 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50882 wxGBPosition result;
50883 void *argp1 = 0 ;
50884 int res1 = 0 ;
50885 PyObject *swig_obj[1] ;
50886
50887 if (!args) SWIG_fail;
50888 swig_obj[0] = args;
50889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50890 if (!SWIG_IsOK(res1)) {
50891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50892 }
50893 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50894 {
50895 PyThreadState* __tstate = wxPyBeginAllowThreads();
50896 result = ((wxGBSizerItem const *)arg1)->GetPos();
50897 wxPyEndAllowThreads(__tstate);
50898 if (PyErr_Occurred()) SWIG_fail;
50899 }
50900 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50901 return resultobj;
50902 fail:
50903 return NULL;
50904 }
50905
50906
50907 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50908 PyObject *resultobj = 0;
50909 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50910 wxGBSpan result;
50911 void *argp1 = 0 ;
50912 int res1 = 0 ;
50913 PyObject *swig_obj[1] ;
50914
50915 if (!args) SWIG_fail;
50916 swig_obj[0] = args;
50917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50918 if (!SWIG_IsOK(res1)) {
50919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50920 }
50921 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50922 {
50923 PyThreadState* __tstate = wxPyBeginAllowThreads();
50924 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50925 wxPyEndAllowThreads(__tstate);
50926 if (PyErr_Occurred()) SWIG_fail;
50927 }
50928 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50929 return resultobj;
50930 fail:
50931 return NULL;
50932 }
50933
50934
50935 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50936 PyObject *resultobj = 0;
50937 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50938 wxGBPosition *arg2 = 0 ;
50939 bool result;
50940 void *argp1 = 0 ;
50941 int res1 = 0 ;
50942 wxGBPosition temp2 ;
50943 PyObject * obj0 = 0 ;
50944 PyObject * obj1 = 0 ;
50945 char * kwnames[] = {
50946 (char *) "self",(char *) "pos", NULL
50947 };
50948
50949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50951 if (!SWIG_IsOK(res1)) {
50952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50953 }
50954 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50955 {
50956 arg2 = &temp2;
50957 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50958 }
50959 {
50960 PyThreadState* __tstate = wxPyBeginAllowThreads();
50961 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50962 wxPyEndAllowThreads(__tstate);
50963 if (PyErr_Occurred()) SWIG_fail;
50964 }
50965 {
50966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50967 }
50968 return resultobj;
50969 fail:
50970 return NULL;
50971 }
50972
50973
50974 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50975 PyObject *resultobj = 0;
50976 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50977 wxGBSpan *arg2 = 0 ;
50978 bool result;
50979 void *argp1 = 0 ;
50980 int res1 = 0 ;
50981 wxGBSpan temp2 ;
50982 PyObject * obj0 = 0 ;
50983 PyObject * obj1 = 0 ;
50984 char * kwnames[] = {
50985 (char *) "self",(char *) "span", NULL
50986 };
50987
50988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50990 if (!SWIG_IsOK(res1)) {
50991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50992 }
50993 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50994 {
50995 arg2 = &temp2;
50996 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50997 }
50998 {
50999 PyThreadState* __tstate = wxPyBeginAllowThreads();
51000 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51001 wxPyEndAllowThreads(__tstate);
51002 if (PyErr_Occurred()) SWIG_fail;
51003 }
51004 {
51005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51006 }
51007 return resultobj;
51008 fail:
51009 return NULL;
51010 }
51011
51012
51013 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51014 PyObject *resultobj = 0;
51015 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51016 wxGBSizerItem *arg2 = 0 ;
51017 bool result;
51018 void *argp1 = 0 ;
51019 int res1 = 0 ;
51020 void *argp2 = 0 ;
51021 int res2 = 0 ;
51022 PyObject * obj0 = 0 ;
51023 PyObject * obj1 = 0 ;
51024 char * kwnames[] = {
51025 (char *) "self",(char *) "other", NULL
51026 };
51027
51028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51030 if (!SWIG_IsOK(res1)) {
51031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51032 }
51033 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51034 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51035 if (!SWIG_IsOK(res2)) {
51036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51037 }
51038 if (!argp2) {
51039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51040 }
51041 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51042 {
51043 PyThreadState* __tstate = wxPyBeginAllowThreads();
51044 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51045 wxPyEndAllowThreads(__tstate);
51046 if (PyErr_Occurred()) SWIG_fail;
51047 }
51048 {
51049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51050 }
51051 return resultobj;
51052 fail:
51053 return NULL;
51054 }
51055
51056
51057 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51058 PyObject *resultobj = 0;
51059 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51060 wxGBPosition *arg2 = 0 ;
51061 wxGBSpan *arg3 = 0 ;
51062 bool result;
51063 void *argp1 = 0 ;
51064 int res1 = 0 ;
51065 wxGBPosition temp2 ;
51066 wxGBSpan temp3 ;
51067 PyObject * obj0 = 0 ;
51068 PyObject * obj1 = 0 ;
51069 PyObject * obj2 = 0 ;
51070 char * kwnames[] = {
51071 (char *) "self",(char *) "pos",(char *) "span", NULL
51072 };
51073
51074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51076 if (!SWIG_IsOK(res1)) {
51077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51078 }
51079 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51080 {
51081 arg2 = &temp2;
51082 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51083 }
51084 {
51085 arg3 = &temp3;
51086 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51087 }
51088 {
51089 PyThreadState* __tstate = wxPyBeginAllowThreads();
51090 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51091 wxPyEndAllowThreads(__tstate);
51092 if (PyErr_Occurred()) SWIG_fail;
51093 }
51094 {
51095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51096 }
51097 return resultobj;
51098 fail:
51099 return NULL;
51100 }
51101
51102
51103 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51104 PyObject *resultobj = 0;
51105 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51106 wxGBPosition result;
51107 void *argp1 = 0 ;
51108 int res1 = 0 ;
51109 PyObject *swig_obj[1] ;
51110
51111 if (!args) SWIG_fail;
51112 swig_obj[0] = args;
51113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51114 if (!SWIG_IsOK(res1)) {
51115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51116 }
51117 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51118 {
51119 PyThreadState* __tstate = wxPyBeginAllowThreads();
51120 result = wxGBSizerItem_GetEndPos(arg1);
51121 wxPyEndAllowThreads(__tstate);
51122 if (PyErr_Occurred()) SWIG_fail;
51123 }
51124 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51125 return resultobj;
51126 fail:
51127 return NULL;
51128 }
51129
51130
51131 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51132 PyObject *resultobj = 0;
51133 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51134 wxGridBagSizer *result = 0 ;
51135 void *argp1 = 0 ;
51136 int res1 = 0 ;
51137 PyObject *swig_obj[1] ;
51138
51139 if (!args) SWIG_fail;
51140 swig_obj[0] = args;
51141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51142 if (!SWIG_IsOK(res1)) {
51143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51144 }
51145 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51146 {
51147 PyThreadState* __tstate = wxPyBeginAllowThreads();
51148 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51149 wxPyEndAllowThreads(__tstate);
51150 if (PyErr_Occurred()) SWIG_fail;
51151 }
51152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51153 return resultobj;
51154 fail:
51155 return NULL;
51156 }
51157
51158
51159 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51160 PyObject *resultobj = 0;
51161 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51162 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51163 void *argp1 = 0 ;
51164 int res1 = 0 ;
51165 void *argp2 = 0 ;
51166 int res2 = 0 ;
51167 PyObject * obj0 = 0 ;
51168 PyObject * obj1 = 0 ;
51169 char * kwnames[] = {
51170 (char *) "self",(char *) "sizer", NULL
51171 };
51172
51173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51175 if (!SWIG_IsOK(res1)) {
51176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51177 }
51178 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51180 if (!SWIG_IsOK(res2)) {
51181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51182 }
51183 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51184 {
51185 PyThreadState* __tstate = wxPyBeginAllowThreads();
51186 (arg1)->SetGBSizer(arg2);
51187 wxPyEndAllowThreads(__tstate);
51188 if (PyErr_Occurred()) SWIG_fail;
51189 }
51190 resultobj = SWIG_Py_Void();
51191 return resultobj;
51192 fail:
51193 return NULL;
51194 }
51195
51196
51197 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51198 PyObject *obj;
51199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51200 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51201 return SWIG_Py_Void();
51202 }
51203
51204 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51205 return SWIG_Python_InitShadowInstance(args);
51206 }
51207
51208 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51209 PyObject *resultobj = 0;
51210 int arg1 = (int) 0 ;
51211 int arg2 = (int) 0 ;
51212 wxGridBagSizer *result = 0 ;
51213 int val1 ;
51214 int ecode1 = 0 ;
51215 int val2 ;
51216 int ecode2 = 0 ;
51217 PyObject * obj0 = 0 ;
51218 PyObject * obj1 = 0 ;
51219 char * kwnames[] = {
51220 (char *) "vgap",(char *) "hgap", NULL
51221 };
51222
51223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51224 if (obj0) {
51225 ecode1 = SWIG_AsVal_int(obj0, &val1);
51226 if (!SWIG_IsOK(ecode1)) {
51227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51228 }
51229 arg1 = static_cast< int >(val1);
51230 }
51231 if (obj1) {
51232 ecode2 = SWIG_AsVal_int(obj1, &val2);
51233 if (!SWIG_IsOK(ecode2)) {
51234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51235 }
51236 arg2 = static_cast< int >(val2);
51237 }
51238 {
51239 PyThreadState* __tstate = wxPyBeginAllowThreads();
51240 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51241 wxPyEndAllowThreads(__tstate);
51242 if (PyErr_Occurred()) SWIG_fail;
51243 }
51244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51245 return resultobj;
51246 fail:
51247 return NULL;
51248 }
51249
51250
51251 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51252 PyObject *resultobj = 0;
51253 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51254 PyObject *arg2 = (PyObject *) 0 ;
51255 wxGBPosition *arg3 = 0 ;
51256 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51257 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51258 int arg5 = (int) 0 ;
51259 int arg6 = (int) 0 ;
51260 PyObject *arg7 = (PyObject *) NULL ;
51261 wxGBSizerItem *result = 0 ;
51262 void *argp1 = 0 ;
51263 int res1 = 0 ;
51264 wxGBPosition temp3 ;
51265 wxGBSpan temp4 ;
51266 int val5 ;
51267 int ecode5 = 0 ;
51268 int val6 ;
51269 int ecode6 = 0 ;
51270 PyObject * obj0 = 0 ;
51271 PyObject * obj1 = 0 ;
51272 PyObject * obj2 = 0 ;
51273 PyObject * obj3 = 0 ;
51274 PyObject * obj4 = 0 ;
51275 PyObject * obj5 = 0 ;
51276 PyObject * obj6 = 0 ;
51277 char * kwnames[] = {
51278 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51279 };
51280
51281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51283 if (!SWIG_IsOK(res1)) {
51284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51285 }
51286 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51287 arg2 = obj1;
51288 {
51289 arg3 = &temp3;
51290 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51291 }
51292 if (obj3) {
51293 {
51294 arg4 = &temp4;
51295 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51296 }
51297 }
51298 if (obj4) {
51299 ecode5 = SWIG_AsVal_int(obj4, &val5);
51300 if (!SWIG_IsOK(ecode5)) {
51301 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51302 }
51303 arg5 = static_cast< int >(val5);
51304 }
51305 if (obj5) {
51306 ecode6 = SWIG_AsVal_int(obj5, &val6);
51307 if (!SWIG_IsOK(ecode6)) {
51308 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51309 }
51310 arg6 = static_cast< int >(val6);
51311 }
51312 if (obj6) {
51313 arg7 = obj6;
51314 }
51315 {
51316 PyThreadState* __tstate = wxPyBeginAllowThreads();
51317 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51318 wxPyEndAllowThreads(__tstate);
51319 if (PyErr_Occurred()) SWIG_fail;
51320 }
51321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51322 return resultobj;
51323 fail:
51324 return NULL;
51325 }
51326
51327
51328 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51329 PyObject *resultobj = 0;
51330 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51331 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51332 wxGBSizerItem *result = 0 ;
51333 void *argp1 = 0 ;
51334 int res1 = 0 ;
51335 int res2 = 0 ;
51336 PyObject * obj0 = 0 ;
51337 PyObject * obj1 = 0 ;
51338 char * kwnames[] = {
51339 (char *) "self",(char *) "item", NULL
51340 };
51341
51342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51344 if (!SWIG_IsOK(res1)) {
51345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51346 }
51347 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51348 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51349 if (!SWIG_IsOK(res2)) {
51350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51351 }
51352 {
51353 PyThreadState* __tstate = wxPyBeginAllowThreads();
51354 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51355 wxPyEndAllowThreads(__tstate);
51356 if (PyErr_Occurred()) SWIG_fail;
51357 }
51358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51359 return resultobj;
51360 fail:
51361 return NULL;
51362 }
51363
51364
51365 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51366 PyObject *resultobj = 0;
51367 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51368 int arg2 ;
51369 int arg3 ;
51370 wxSize result;
51371 void *argp1 = 0 ;
51372 int res1 = 0 ;
51373 int val2 ;
51374 int ecode2 = 0 ;
51375 int val3 ;
51376 int ecode3 = 0 ;
51377 PyObject * obj0 = 0 ;
51378 PyObject * obj1 = 0 ;
51379 PyObject * obj2 = 0 ;
51380 char * kwnames[] = {
51381 (char *) "self",(char *) "row",(char *) "col", NULL
51382 };
51383
51384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51386 if (!SWIG_IsOK(res1)) {
51387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51388 }
51389 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51390 ecode2 = SWIG_AsVal_int(obj1, &val2);
51391 if (!SWIG_IsOK(ecode2)) {
51392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51393 }
51394 arg2 = static_cast< int >(val2);
51395 ecode3 = SWIG_AsVal_int(obj2, &val3);
51396 if (!SWIG_IsOK(ecode3)) {
51397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51398 }
51399 arg3 = static_cast< int >(val3);
51400 {
51401 PyThreadState* __tstate = wxPyBeginAllowThreads();
51402 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51403 wxPyEndAllowThreads(__tstate);
51404 if (PyErr_Occurred()) SWIG_fail;
51405 }
51406 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51407 return resultobj;
51408 fail:
51409 return NULL;
51410 }
51411
51412
51413 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51414 PyObject *resultobj = 0;
51415 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51416 wxSize result;
51417 void *argp1 = 0 ;
51418 int res1 = 0 ;
51419 PyObject *swig_obj[1] ;
51420
51421 if (!args) SWIG_fail;
51422 swig_obj[0] = args;
51423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51424 if (!SWIG_IsOK(res1)) {
51425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51426 }
51427 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51428 {
51429 PyThreadState* __tstate = wxPyBeginAllowThreads();
51430 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51431 wxPyEndAllowThreads(__tstate);
51432 if (PyErr_Occurred()) SWIG_fail;
51433 }
51434 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51435 return resultobj;
51436 fail:
51437 return NULL;
51438 }
51439
51440
51441 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51442 PyObject *resultobj = 0;
51443 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51444 wxSize *arg2 = 0 ;
51445 void *argp1 = 0 ;
51446 int res1 = 0 ;
51447 wxSize temp2 ;
51448 PyObject * obj0 = 0 ;
51449 PyObject * obj1 = 0 ;
51450 char * kwnames[] = {
51451 (char *) "self",(char *) "sz", NULL
51452 };
51453
51454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51456 if (!SWIG_IsOK(res1)) {
51457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51458 }
51459 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51460 {
51461 arg2 = &temp2;
51462 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51463 }
51464 {
51465 PyThreadState* __tstate = wxPyBeginAllowThreads();
51466 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51467 wxPyEndAllowThreads(__tstate);
51468 if (PyErr_Occurred()) SWIG_fail;
51469 }
51470 resultobj = SWIG_Py_Void();
51471 return resultobj;
51472 fail:
51473 return NULL;
51474 }
51475
51476
51477 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51478 PyObject *resultobj = 0;
51479 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51480 wxWindow *arg2 = (wxWindow *) 0 ;
51481 wxGBPosition result;
51482 void *argp1 = 0 ;
51483 int res1 = 0 ;
51484 void *argp2 = 0 ;
51485 int res2 = 0 ;
51486
51487 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51489 if (!SWIG_IsOK(res1)) {
51490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51491 }
51492 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51493 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51494 if (!SWIG_IsOK(res2)) {
51495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51496 }
51497 arg2 = reinterpret_cast< wxWindow * >(argp2);
51498 {
51499 PyThreadState* __tstate = wxPyBeginAllowThreads();
51500 result = (arg1)->GetItemPosition(arg2);
51501 wxPyEndAllowThreads(__tstate);
51502 if (PyErr_Occurred()) SWIG_fail;
51503 }
51504 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51505 return resultobj;
51506 fail:
51507 return NULL;
51508 }
51509
51510
51511 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51512 PyObject *resultobj = 0;
51513 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51514 wxSizer *arg2 = (wxSizer *) 0 ;
51515 wxGBPosition result;
51516 void *argp1 = 0 ;
51517 int res1 = 0 ;
51518 void *argp2 = 0 ;
51519 int res2 = 0 ;
51520
51521 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51523 if (!SWIG_IsOK(res1)) {
51524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51525 }
51526 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51527 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51528 if (!SWIG_IsOK(res2)) {
51529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51530 }
51531 arg2 = reinterpret_cast< wxSizer * >(argp2);
51532 {
51533 PyThreadState* __tstate = wxPyBeginAllowThreads();
51534 result = (arg1)->GetItemPosition(arg2);
51535 wxPyEndAllowThreads(__tstate);
51536 if (PyErr_Occurred()) SWIG_fail;
51537 }
51538 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51539 return resultobj;
51540 fail:
51541 return NULL;
51542 }
51543
51544
51545 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51546 PyObject *resultobj = 0;
51547 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51548 size_t arg2 ;
51549 wxGBPosition result;
51550 void *argp1 = 0 ;
51551 int res1 = 0 ;
51552 size_t val2 ;
51553 int ecode2 = 0 ;
51554
51555 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51557 if (!SWIG_IsOK(res1)) {
51558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51559 }
51560 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51561 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51562 if (!SWIG_IsOK(ecode2)) {
51563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51564 }
51565 arg2 = static_cast< size_t >(val2);
51566 {
51567 PyThreadState* __tstate = wxPyBeginAllowThreads();
51568 result = (arg1)->GetItemPosition(arg2);
51569 wxPyEndAllowThreads(__tstate);
51570 if (PyErr_Occurred()) SWIG_fail;
51571 }
51572 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51573 return resultobj;
51574 fail:
51575 return NULL;
51576 }
51577
51578
51579 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51580 int argc;
51581 PyObject *argv[3];
51582
51583 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51584 --argc;
51585 if (argc == 2) {
51586 int _v = 0;
51587 {
51588 void *vptr = 0;
51589 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51590 _v = SWIG_CheckState(res);
51591 }
51592 if (!_v) goto check_1;
51593 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51594 }
51595 check_1:
51596
51597 if (argc == 2) {
51598 int _v = 0;
51599 {
51600 void *vptr = 0;
51601 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51602 _v = SWIG_CheckState(res);
51603 }
51604 if (!_v) goto check_2;
51605 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51606 }
51607 check_2:
51608
51609 if (argc == 2) {
51610 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51611 }
51612
51613 fail:
51614 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51615 return NULL;
51616 }
51617
51618
51619 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51620 PyObject *resultobj = 0;
51621 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51622 wxWindow *arg2 = (wxWindow *) 0 ;
51623 wxGBPosition *arg3 = 0 ;
51624 bool result;
51625 void *argp1 = 0 ;
51626 int res1 = 0 ;
51627 void *argp2 = 0 ;
51628 int res2 = 0 ;
51629 wxGBPosition temp3 ;
51630
51631 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51633 if (!SWIG_IsOK(res1)) {
51634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51635 }
51636 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51638 if (!SWIG_IsOK(res2)) {
51639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51640 }
51641 arg2 = reinterpret_cast< wxWindow * >(argp2);
51642 {
51643 arg3 = &temp3;
51644 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51645 }
51646 {
51647 PyThreadState* __tstate = wxPyBeginAllowThreads();
51648 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51649 wxPyEndAllowThreads(__tstate);
51650 if (PyErr_Occurred()) SWIG_fail;
51651 }
51652 {
51653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51654 }
51655 return resultobj;
51656 fail:
51657 return NULL;
51658 }
51659
51660
51661 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51662 PyObject *resultobj = 0;
51663 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51664 wxSizer *arg2 = (wxSizer *) 0 ;
51665 wxGBPosition *arg3 = 0 ;
51666 bool result;
51667 void *argp1 = 0 ;
51668 int res1 = 0 ;
51669 void *argp2 = 0 ;
51670 int res2 = 0 ;
51671 wxGBPosition temp3 ;
51672
51673 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51675 if (!SWIG_IsOK(res1)) {
51676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51677 }
51678 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51679 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51680 if (!SWIG_IsOK(res2)) {
51681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51682 }
51683 arg2 = reinterpret_cast< wxSizer * >(argp2);
51684 {
51685 arg3 = &temp3;
51686 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51687 }
51688 {
51689 PyThreadState* __tstate = wxPyBeginAllowThreads();
51690 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51691 wxPyEndAllowThreads(__tstate);
51692 if (PyErr_Occurred()) SWIG_fail;
51693 }
51694 {
51695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51696 }
51697 return resultobj;
51698 fail:
51699 return NULL;
51700 }
51701
51702
51703 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51704 PyObject *resultobj = 0;
51705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51706 size_t arg2 ;
51707 wxGBPosition *arg3 = 0 ;
51708 bool result;
51709 void *argp1 = 0 ;
51710 int res1 = 0 ;
51711 size_t val2 ;
51712 int ecode2 = 0 ;
51713 wxGBPosition temp3 ;
51714
51715 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51717 if (!SWIG_IsOK(res1)) {
51718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51719 }
51720 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51721 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51722 if (!SWIG_IsOK(ecode2)) {
51723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51724 }
51725 arg2 = static_cast< size_t >(val2);
51726 {
51727 arg3 = &temp3;
51728 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51729 }
51730 {
51731 PyThreadState* __tstate = wxPyBeginAllowThreads();
51732 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51733 wxPyEndAllowThreads(__tstate);
51734 if (PyErr_Occurred()) SWIG_fail;
51735 }
51736 {
51737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51738 }
51739 return resultobj;
51740 fail:
51741 return NULL;
51742 }
51743
51744
51745 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51746 int argc;
51747 PyObject *argv[4];
51748
51749 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51750 --argc;
51751 if (argc == 3) {
51752 int _v = 0;
51753 {
51754 void *vptr = 0;
51755 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51756 _v = SWIG_CheckState(res);
51757 }
51758 if (!_v) goto check_1;
51759 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51760 }
51761 check_1:
51762
51763 if (argc == 3) {
51764 int _v = 0;
51765 {
51766 void *vptr = 0;
51767 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51768 _v = SWIG_CheckState(res);
51769 }
51770 if (!_v) goto check_2;
51771 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51772 }
51773 check_2:
51774
51775 if (argc == 3) {
51776 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51777 }
51778
51779 fail:
51780 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51781 return NULL;
51782 }
51783
51784
51785 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51786 PyObject *resultobj = 0;
51787 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51788 wxWindow *arg2 = (wxWindow *) 0 ;
51789 wxGBSpan result;
51790 void *argp1 = 0 ;
51791 int res1 = 0 ;
51792 void *argp2 = 0 ;
51793 int res2 = 0 ;
51794
51795 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51797 if (!SWIG_IsOK(res1)) {
51798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51799 }
51800 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51801 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51802 if (!SWIG_IsOK(res2)) {
51803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51804 }
51805 arg2 = reinterpret_cast< wxWindow * >(argp2);
51806 {
51807 PyThreadState* __tstate = wxPyBeginAllowThreads();
51808 result = (arg1)->GetItemSpan(arg2);
51809 wxPyEndAllowThreads(__tstate);
51810 if (PyErr_Occurred()) SWIG_fail;
51811 }
51812 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51813 return resultobj;
51814 fail:
51815 return NULL;
51816 }
51817
51818
51819 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51820 PyObject *resultobj = 0;
51821 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51822 wxSizer *arg2 = (wxSizer *) 0 ;
51823 wxGBSpan result;
51824 void *argp1 = 0 ;
51825 int res1 = 0 ;
51826 void *argp2 = 0 ;
51827 int res2 = 0 ;
51828
51829 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51831 if (!SWIG_IsOK(res1)) {
51832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51833 }
51834 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51835 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51836 if (!SWIG_IsOK(res2)) {
51837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51838 }
51839 arg2 = reinterpret_cast< wxSizer * >(argp2);
51840 {
51841 PyThreadState* __tstate = wxPyBeginAllowThreads();
51842 result = (arg1)->GetItemSpan(arg2);
51843 wxPyEndAllowThreads(__tstate);
51844 if (PyErr_Occurred()) SWIG_fail;
51845 }
51846 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51847 return resultobj;
51848 fail:
51849 return NULL;
51850 }
51851
51852
51853 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51854 PyObject *resultobj = 0;
51855 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51856 size_t arg2 ;
51857 wxGBSpan result;
51858 void *argp1 = 0 ;
51859 int res1 = 0 ;
51860 size_t val2 ;
51861 int ecode2 = 0 ;
51862
51863 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51865 if (!SWIG_IsOK(res1)) {
51866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51867 }
51868 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51869 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51870 if (!SWIG_IsOK(ecode2)) {
51871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51872 }
51873 arg2 = static_cast< size_t >(val2);
51874 {
51875 PyThreadState* __tstate = wxPyBeginAllowThreads();
51876 result = (arg1)->GetItemSpan(arg2);
51877 wxPyEndAllowThreads(__tstate);
51878 if (PyErr_Occurred()) SWIG_fail;
51879 }
51880 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51881 return resultobj;
51882 fail:
51883 return NULL;
51884 }
51885
51886
51887 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51888 int argc;
51889 PyObject *argv[3];
51890
51891 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51892 --argc;
51893 if (argc == 2) {
51894 int _v = 0;
51895 {
51896 void *vptr = 0;
51897 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51898 _v = SWIG_CheckState(res);
51899 }
51900 if (!_v) goto check_1;
51901 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51902 }
51903 check_1:
51904
51905 if (argc == 2) {
51906 int _v = 0;
51907 {
51908 void *vptr = 0;
51909 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51910 _v = SWIG_CheckState(res);
51911 }
51912 if (!_v) goto check_2;
51913 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51914 }
51915 check_2:
51916
51917 if (argc == 2) {
51918 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51919 }
51920
51921 fail:
51922 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51923 return NULL;
51924 }
51925
51926
51927 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51928 PyObject *resultobj = 0;
51929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51930 wxWindow *arg2 = (wxWindow *) 0 ;
51931 wxGBSpan *arg3 = 0 ;
51932 bool result;
51933 void *argp1 = 0 ;
51934 int res1 = 0 ;
51935 void *argp2 = 0 ;
51936 int res2 = 0 ;
51937 wxGBSpan temp3 ;
51938
51939 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51941 if (!SWIG_IsOK(res1)) {
51942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51943 }
51944 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51945 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51946 if (!SWIG_IsOK(res2)) {
51947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51948 }
51949 arg2 = reinterpret_cast< wxWindow * >(argp2);
51950 {
51951 arg3 = &temp3;
51952 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51953 }
51954 {
51955 PyThreadState* __tstate = wxPyBeginAllowThreads();
51956 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51957 wxPyEndAllowThreads(__tstate);
51958 if (PyErr_Occurred()) SWIG_fail;
51959 }
51960 {
51961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51962 }
51963 return resultobj;
51964 fail:
51965 return NULL;
51966 }
51967
51968
51969 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51970 PyObject *resultobj = 0;
51971 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51972 wxSizer *arg2 = (wxSizer *) 0 ;
51973 wxGBSpan *arg3 = 0 ;
51974 bool result;
51975 void *argp1 = 0 ;
51976 int res1 = 0 ;
51977 void *argp2 = 0 ;
51978 int res2 = 0 ;
51979 wxGBSpan temp3 ;
51980
51981 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51983 if (!SWIG_IsOK(res1)) {
51984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51985 }
51986 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51987 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51988 if (!SWIG_IsOK(res2)) {
51989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51990 }
51991 arg2 = reinterpret_cast< wxSizer * >(argp2);
51992 {
51993 arg3 = &temp3;
51994 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51995 }
51996 {
51997 PyThreadState* __tstate = wxPyBeginAllowThreads();
51998 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51999 wxPyEndAllowThreads(__tstate);
52000 if (PyErr_Occurred()) SWIG_fail;
52001 }
52002 {
52003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52004 }
52005 return resultobj;
52006 fail:
52007 return NULL;
52008 }
52009
52010
52011 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52012 PyObject *resultobj = 0;
52013 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52014 size_t arg2 ;
52015 wxGBSpan *arg3 = 0 ;
52016 bool result;
52017 void *argp1 = 0 ;
52018 int res1 = 0 ;
52019 size_t val2 ;
52020 int ecode2 = 0 ;
52021 wxGBSpan temp3 ;
52022
52023 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52025 if (!SWIG_IsOK(res1)) {
52026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52027 }
52028 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52029 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52030 if (!SWIG_IsOK(ecode2)) {
52031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52032 }
52033 arg2 = static_cast< size_t >(val2);
52034 {
52035 arg3 = &temp3;
52036 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52037 }
52038 {
52039 PyThreadState* __tstate = wxPyBeginAllowThreads();
52040 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52041 wxPyEndAllowThreads(__tstate);
52042 if (PyErr_Occurred()) SWIG_fail;
52043 }
52044 {
52045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52046 }
52047 return resultobj;
52048 fail:
52049 return NULL;
52050 }
52051
52052
52053 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52054 int argc;
52055 PyObject *argv[4];
52056
52057 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52058 --argc;
52059 if (argc == 3) {
52060 int _v = 0;
52061 {
52062 void *vptr = 0;
52063 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52064 _v = SWIG_CheckState(res);
52065 }
52066 if (!_v) goto check_1;
52067 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52068 }
52069 check_1:
52070
52071 if (argc == 3) {
52072 int _v = 0;
52073 {
52074 void *vptr = 0;
52075 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52076 _v = SWIG_CheckState(res);
52077 }
52078 if (!_v) goto check_2;
52079 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52080 }
52081 check_2:
52082
52083 if (argc == 3) {
52084 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52085 }
52086
52087 fail:
52088 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52089 return NULL;
52090 }
52091
52092
52093 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52094 PyObject *resultobj = 0;
52095 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52096 wxWindow *arg2 = (wxWindow *) 0 ;
52097 wxGBSizerItem *result = 0 ;
52098 void *argp1 = 0 ;
52099 int res1 = 0 ;
52100 void *argp2 = 0 ;
52101 int res2 = 0 ;
52102
52103 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52105 if (!SWIG_IsOK(res1)) {
52106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52107 }
52108 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52109 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52110 if (!SWIG_IsOK(res2)) {
52111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52112 }
52113 arg2 = reinterpret_cast< wxWindow * >(argp2);
52114 {
52115 PyThreadState* __tstate = wxPyBeginAllowThreads();
52116 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52117 wxPyEndAllowThreads(__tstate);
52118 if (PyErr_Occurred()) SWIG_fail;
52119 }
52120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52121 return resultobj;
52122 fail:
52123 return NULL;
52124 }
52125
52126
52127 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52128 PyObject *resultobj = 0;
52129 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52130 wxSizer *arg2 = (wxSizer *) 0 ;
52131 wxGBSizerItem *result = 0 ;
52132 void *argp1 = 0 ;
52133 int res1 = 0 ;
52134 void *argp2 = 0 ;
52135 int res2 = 0 ;
52136
52137 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52139 if (!SWIG_IsOK(res1)) {
52140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52141 }
52142 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52143 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52144 if (!SWIG_IsOK(res2)) {
52145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52146 }
52147 arg2 = reinterpret_cast< wxSizer * >(argp2);
52148 {
52149 PyThreadState* __tstate = wxPyBeginAllowThreads();
52150 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52151 wxPyEndAllowThreads(__tstate);
52152 if (PyErr_Occurred()) SWIG_fail;
52153 }
52154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52155 return resultobj;
52156 fail:
52157 return NULL;
52158 }
52159
52160
52161 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52162 int argc;
52163 PyObject *argv[3];
52164
52165 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52166 --argc;
52167 if (argc == 2) {
52168 int _v = 0;
52169 {
52170 void *vptr = 0;
52171 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52172 _v = SWIG_CheckState(res);
52173 }
52174 if (!_v) goto check_1;
52175 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52176 }
52177 check_1:
52178
52179 if (argc == 2) {
52180 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52181 }
52182
52183 fail:
52184 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52190 PyObject *resultobj = 0;
52191 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52192 wxGBPosition *arg2 = 0 ;
52193 wxGBSizerItem *result = 0 ;
52194 void *argp1 = 0 ;
52195 int res1 = 0 ;
52196 wxGBPosition temp2 ;
52197 PyObject * obj0 = 0 ;
52198 PyObject * obj1 = 0 ;
52199 char * kwnames[] = {
52200 (char *) "self",(char *) "pos", NULL
52201 };
52202
52203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52205 if (!SWIG_IsOK(res1)) {
52206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52207 }
52208 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52209 {
52210 arg2 = &temp2;
52211 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52212 }
52213 {
52214 PyThreadState* __tstate = wxPyBeginAllowThreads();
52215 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52216 wxPyEndAllowThreads(__tstate);
52217 if (PyErr_Occurred()) SWIG_fail;
52218 }
52219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52220 return resultobj;
52221 fail:
52222 return NULL;
52223 }
52224
52225
52226 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52227 PyObject *resultobj = 0;
52228 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52229 wxPoint *arg2 = 0 ;
52230 wxGBSizerItem *result = 0 ;
52231 void *argp1 = 0 ;
52232 int res1 = 0 ;
52233 wxPoint temp2 ;
52234 PyObject * obj0 = 0 ;
52235 PyObject * obj1 = 0 ;
52236 char * kwnames[] = {
52237 (char *) "self",(char *) "pt", NULL
52238 };
52239
52240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52242 if (!SWIG_IsOK(res1)) {
52243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52244 }
52245 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52246 {
52247 arg2 = &temp2;
52248 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52249 }
52250 {
52251 PyThreadState* __tstate = wxPyBeginAllowThreads();
52252 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52253 wxPyEndAllowThreads(__tstate);
52254 if (PyErr_Occurred()) SWIG_fail;
52255 }
52256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52257 return resultobj;
52258 fail:
52259 return NULL;
52260 }
52261
52262
52263 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52264 PyObject *resultobj = 0;
52265 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52266 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52267 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52268 bool result;
52269 void *argp1 = 0 ;
52270 int res1 = 0 ;
52271 void *argp2 = 0 ;
52272 int res2 = 0 ;
52273 void *argp3 = 0 ;
52274 int res3 = 0 ;
52275 PyObject * obj0 = 0 ;
52276 PyObject * obj1 = 0 ;
52277 PyObject * obj2 = 0 ;
52278 char * kwnames[] = {
52279 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52280 };
52281
52282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52284 if (!SWIG_IsOK(res1)) {
52285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52286 }
52287 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52289 if (!SWIG_IsOK(res2)) {
52290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52291 }
52292 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52293 if (obj2) {
52294 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52295 if (!SWIG_IsOK(res3)) {
52296 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52297 }
52298 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52299 }
52300 {
52301 PyThreadState* __tstate = wxPyBeginAllowThreads();
52302 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52303 wxPyEndAllowThreads(__tstate);
52304 if (PyErr_Occurred()) SWIG_fail;
52305 }
52306 {
52307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52308 }
52309 return resultobj;
52310 fail:
52311 return NULL;
52312 }
52313
52314
52315 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52316 PyObject *resultobj = 0;
52317 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52318 wxGBPosition *arg2 = 0 ;
52319 wxGBSpan *arg3 = 0 ;
52320 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52321 bool result;
52322 void *argp1 = 0 ;
52323 int res1 = 0 ;
52324 wxGBPosition temp2 ;
52325 wxGBSpan temp3 ;
52326 void *argp4 = 0 ;
52327 int res4 = 0 ;
52328 PyObject * obj0 = 0 ;
52329 PyObject * obj1 = 0 ;
52330 PyObject * obj2 = 0 ;
52331 PyObject * obj3 = 0 ;
52332 char * kwnames[] = {
52333 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52334 };
52335
52336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52338 if (!SWIG_IsOK(res1)) {
52339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52340 }
52341 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52342 {
52343 arg2 = &temp2;
52344 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52345 }
52346 {
52347 arg3 = &temp3;
52348 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52349 }
52350 if (obj3) {
52351 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52352 if (!SWIG_IsOK(res4)) {
52353 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52354 }
52355 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52356 }
52357 {
52358 PyThreadState* __tstate = wxPyBeginAllowThreads();
52359 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52360 wxPyEndAllowThreads(__tstate);
52361 if (PyErr_Occurred()) SWIG_fail;
52362 }
52363 {
52364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52365 }
52366 return resultobj;
52367 fail:
52368 return NULL;
52369 }
52370
52371
52372 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52373 PyObject *obj;
52374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52375 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52376 return SWIG_Py_Void();
52377 }
52378
52379 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52380 return SWIG_Python_InitShadowInstance(args);
52381 }
52382
52383 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52384 PyObject *resultobj = 0;
52385 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52386 wxRelationship arg2 ;
52387 wxWindow *arg3 = (wxWindow *) 0 ;
52388 wxEdge arg4 ;
52389 int arg5 = (int) 0 ;
52390 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52391 void *argp1 = 0 ;
52392 int res1 = 0 ;
52393 int val2 ;
52394 int ecode2 = 0 ;
52395 void *argp3 = 0 ;
52396 int res3 = 0 ;
52397 int val4 ;
52398 int ecode4 = 0 ;
52399 int val5 ;
52400 int ecode5 = 0 ;
52401 int val6 ;
52402 int ecode6 = 0 ;
52403 PyObject * obj0 = 0 ;
52404 PyObject * obj1 = 0 ;
52405 PyObject * obj2 = 0 ;
52406 PyObject * obj3 = 0 ;
52407 PyObject * obj4 = 0 ;
52408 PyObject * obj5 = 0 ;
52409 char * kwnames[] = {
52410 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52411 };
52412
52413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52415 if (!SWIG_IsOK(res1)) {
52416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52417 }
52418 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52419 ecode2 = SWIG_AsVal_int(obj1, &val2);
52420 if (!SWIG_IsOK(ecode2)) {
52421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52422 }
52423 arg2 = static_cast< wxRelationship >(val2);
52424 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52425 if (!SWIG_IsOK(res3)) {
52426 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52427 }
52428 arg3 = reinterpret_cast< wxWindow * >(argp3);
52429 ecode4 = SWIG_AsVal_int(obj3, &val4);
52430 if (!SWIG_IsOK(ecode4)) {
52431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52432 }
52433 arg4 = static_cast< wxEdge >(val4);
52434 if (obj4) {
52435 ecode5 = SWIG_AsVal_int(obj4, &val5);
52436 if (!SWIG_IsOK(ecode5)) {
52437 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52438 }
52439 arg5 = static_cast< int >(val5);
52440 }
52441 if (obj5) {
52442 ecode6 = SWIG_AsVal_int(obj5, &val6);
52443 if (!SWIG_IsOK(ecode6)) {
52444 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52445 }
52446 arg6 = static_cast< int >(val6);
52447 }
52448 {
52449 PyThreadState* __tstate = wxPyBeginAllowThreads();
52450 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52451 wxPyEndAllowThreads(__tstate);
52452 if (PyErr_Occurred()) SWIG_fail;
52453 }
52454 resultobj = SWIG_Py_Void();
52455 return resultobj;
52456 fail:
52457 return NULL;
52458 }
52459
52460
52461 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52462 PyObject *resultobj = 0;
52463 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52464 wxWindow *arg2 = (wxWindow *) 0 ;
52465 int arg3 = (int) 0 ;
52466 void *argp1 = 0 ;
52467 int res1 = 0 ;
52468 void *argp2 = 0 ;
52469 int res2 = 0 ;
52470 int val3 ;
52471 int ecode3 = 0 ;
52472 PyObject * obj0 = 0 ;
52473 PyObject * obj1 = 0 ;
52474 PyObject * obj2 = 0 ;
52475 char * kwnames[] = {
52476 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52477 };
52478
52479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52481 if (!SWIG_IsOK(res1)) {
52482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52483 }
52484 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52486 if (!SWIG_IsOK(res2)) {
52487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52488 }
52489 arg2 = reinterpret_cast< wxWindow * >(argp2);
52490 if (obj2) {
52491 ecode3 = SWIG_AsVal_int(obj2, &val3);
52492 if (!SWIG_IsOK(ecode3)) {
52493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52494 }
52495 arg3 = static_cast< int >(val3);
52496 }
52497 {
52498 PyThreadState* __tstate = wxPyBeginAllowThreads();
52499 (arg1)->LeftOf(arg2,arg3);
52500 wxPyEndAllowThreads(__tstate);
52501 if (PyErr_Occurred()) SWIG_fail;
52502 }
52503 resultobj = SWIG_Py_Void();
52504 return resultobj;
52505 fail:
52506 return NULL;
52507 }
52508
52509
52510 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52511 PyObject *resultobj = 0;
52512 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52513 wxWindow *arg2 = (wxWindow *) 0 ;
52514 int arg3 = (int) 0 ;
52515 void *argp1 = 0 ;
52516 int res1 = 0 ;
52517 void *argp2 = 0 ;
52518 int res2 = 0 ;
52519 int val3 ;
52520 int ecode3 = 0 ;
52521 PyObject * obj0 = 0 ;
52522 PyObject * obj1 = 0 ;
52523 PyObject * obj2 = 0 ;
52524 char * kwnames[] = {
52525 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52526 };
52527
52528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52530 if (!SWIG_IsOK(res1)) {
52531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52532 }
52533 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52534 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52535 if (!SWIG_IsOK(res2)) {
52536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52537 }
52538 arg2 = reinterpret_cast< wxWindow * >(argp2);
52539 if (obj2) {
52540 ecode3 = SWIG_AsVal_int(obj2, &val3);
52541 if (!SWIG_IsOK(ecode3)) {
52542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52543 }
52544 arg3 = static_cast< int >(val3);
52545 }
52546 {
52547 PyThreadState* __tstate = wxPyBeginAllowThreads();
52548 (arg1)->RightOf(arg2,arg3);
52549 wxPyEndAllowThreads(__tstate);
52550 if (PyErr_Occurred()) SWIG_fail;
52551 }
52552 resultobj = SWIG_Py_Void();
52553 return resultobj;
52554 fail:
52555 return NULL;
52556 }
52557
52558
52559 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52560 PyObject *resultobj = 0;
52561 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52562 wxWindow *arg2 = (wxWindow *) 0 ;
52563 int arg3 = (int) 0 ;
52564 void *argp1 = 0 ;
52565 int res1 = 0 ;
52566 void *argp2 = 0 ;
52567 int res2 = 0 ;
52568 int val3 ;
52569 int ecode3 = 0 ;
52570 PyObject * obj0 = 0 ;
52571 PyObject * obj1 = 0 ;
52572 PyObject * obj2 = 0 ;
52573 char * kwnames[] = {
52574 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52575 };
52576
52577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52579 if (!SWIG_IsOK(res1)) {
52580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52581 }
52582 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52584 if (!SWIG_IsOK(res2)) {
52585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52586 }
52587 arg2 = reinterpret_cast< wxWindow * >(argp2);
52588 if (obj2) {
52589 ecode3 = SWIG_AsVal_int(obj2, &val3);
52590 if (!SWIG_IsOK(ecode3)) {
52591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52592 }
52593 arg3 = static_cast< int >(val3);
52594 }
52595 {
52596 PyThreadState* __tstate = wxPyBeginAllowThreads();
52597 (arg1)->Above(arg2,arg3);
52598 wxPyEndAllowThreads(__tstate);
52599 if (PyErr_Occurred()) SWIG_fail;
52600 }
52601 resultobj = SWIG_Py_Void();
52602 return resultobj;
52603 fail:
52604 return NULL;
52605 }
52606
52607
52608 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52609 PyObject *resultobj = 0;
52610 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52611 wxWindow *arg2 = (wxWindow *) 0 ;
52612 int arg3 = (int) 0 ;
52613 void *argp1 = 0 ;
52614 int res1 = 0 ;
52615 void *argp2 = 0 ;
52616 int res2 = 0 ;
52617 int val3 ;
52618 int ecode3 = 0 ;
52619 PyObject * obj0 = 0 ;
52620 PyObject * obj1 = 0 ;
52621 PyObject * obj2 = 0 ;
52622 char * kwnames[] = {
52623 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52624 };
52625
52626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52628 if (!SWIG_IsOK(res1)) {
52629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52630 }
52631 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52633 if (!SWIG_IsOK(res2)) {
52634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52635 }
52636 arg2 = reinterpret_cast< wxWindow * >(argp2);
52637 if (obj2) {
52638 ecode3 = SWIG_AsVal_int(obj2, &val3);
52639 if (!SWIG_IsOK(ecode3)) {
52640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52641 }
52642 arg3 = static_cast< int >(val3);
52643 }
52644 {
52645 PyThreadState* __tstate = wxPyBeginAllowThreads();
52646 (arg1)->Below(arg2,arg3);
52647 wxPyEndAllowThreads(__tstate);
52648 if (PyErr_Occurred()) SWIG_fail;
52649 }
52650 resultobj = SWIG_Py_Void();
52651 return resultobj;
52652 fail:
52653 return NULL;
52654 }
52655
52656
52657 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52658 PyObject *resultobj = 0;
52659 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52660 wxWindow *arg2 = (wxWindow *) 0 ;
52661 wxEdge arg3 ;
52662 int arg4 = (int) 0 ;
52663 void *argp1 = 0 ;
52664 int res1 = 0 ;
52665 void *argp2 = 0 ;
52666 int res2 = 0 ;
52667 int val3 ;
52668 int ecode3 = 0 ;
52669 int val4 ;
52670 int ecode4 = 0 ;
52671 PyObject * obj0 = 0 ;
52672 PyObject * obj1 = 0 ;
52673 PyObject * obj2 = 0 ;
52674 PyObject * obj3 = 0 ;
52675 char * kwnames[] = {
52676 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52677 };
52678
52679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52681 if (!SWIG_IsOK(res1)) {
52682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52683 }
52684 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52686 if (!SWIG_IsOK(res2)) {
52687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52688 }
52689 arg2 = reinterpret_cast< wxWindow * >(argp2);
52690 ecode3 = SWIG_AsVal_int(obj2, &val3);
52691 if (!SWIG_IsOK(ecode3)) {
52692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52693 }
52694 arg3 = static_cast< wxEdge >(val3);
52695 if (obj3) {
52696 ecode4 = SWIG_AsVal_int(obj3, &val4);
52697 if (!SWIG_IsOK(ecode4)) {
52698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52699 }
52700 arg4 = static_cast< int >(val4);
52701 }
52702 {
52703 PyThreadState* __tstate = wxPyBeginAllowThreads();
52704 (arg1)->SameAs(arg2,arg3,arg4);
52705 wxPyEndAllowThreads(__tstate);
52706 if (PyErr_Occurred()) SWIG_fail;
52707 }
52708 resultobj = SWIG_Py_Void();
52709 return resultobj;
52710 fail:
52711 return NULL;
52712 }
52713
52714
52715 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52716 PyObject *resultobj = 0;
52717 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52718 wxWindow *arg2 = (wxWindow *) 0 ;
52719 wxEdge arg3 ;
52720 int arg4 ;
52721 void *argp1 = 0 ;
52722 int res1 = 0 ;
52723 void *argp2 = 0 ;
52724 int res2 = 0 ;
52725 int val3 ;
52726 int ecode3 = 0 ;
52727 int val4 ;
52728 int ecode4 = 0 ;
52729 PyObject * obj0 = 0 ;
52730 PyObject * obj1 = 0 ;
52731 PyObject * obj2 = 0 ;
52732 PyObject * obj3 = 0 ;
52733 char * kwnames[] = {
52734 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52735 };
52736
52737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52739 if (!SWIG_IsOK(res1)) {
52740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52741 }
52742 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52744 if (!SWIG_IsOK(res2)) {
52745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52746 }
52747 arg2 = reinterpret_cast< wxWindow * >(argp2);
52748 ecode3 = SWIG_AsVal_int(obj2, &val3);
52749 if (!SWIG_IsOK(ecode3)) {
52750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52751 }
52752 arg3 = static_cast< wxEdge >(val3);
52753 ecode4 = SWIG_AsVal_int(obj3, &val4);
52754 if (!SWIG_IsOK(ecode4)) {
52755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52756 }
52757 arg4 = static_cast< int >(val4);
52758 {
52759 PyThreadState* __tstate = wxPyBeginAllowThreads();
52760 (arg1)->PercentOf(arg2,arg3,arg4);
52761 wxPyEndAllowThreads(__tstate);
52762 if (PyErr_Occurred()) SWIG_fail;
52763 }
52764 resultobj = SWIG_Py_Void();
52765 return resultobj;
52766 fail:
52767 return NULL;
52768 }
52769
52770
52771 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52772 PyObject *resultobj = 0;
52773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52774 int arg2 ;
52775 void *argp1 = 0 ;
52776 int res1 = 0 ;
52777 int val2 ;
52778 int ecode2 = 0 ;
52779 PyObject * obj0 = 0 ;
52780 PyObject * obj1 = 0 ;
52781 char * kwnames[] = {
52782 (char *) "self",(char *) "val", NULL
52783 };
52784
52785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52787 if (!SWIG_IsOK(res1)) {
52788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52789 }
52790 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52791 ecode2 = SWIG_AsVal_int(obj1, &val2);
52792 if (!SWIG_IsOK(ecode2)) {
52793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52794 }
52795 arg2 = static_cast< int >(val2);
52796 {
52797 PyThreadState* __tstate = wxPyBeginAllowThreads();
52798 (arg1)->Absolute(arg2);
52799 wxPyEndAllowThreads(__tstate);
52800 if (PyErr_Occurred()) SWIG_fail;
52801 }
52802 resultobj = SWIG_Py_Void();
52803 return resultobj;
52804 fail:
52805 return NULL;
52806 }
52807
52808
52809 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52810 PyObject *resultobj = 0;
52811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52812 void *argp1 = 0 ;
52813 int res1 = 0 ;
52814 PyObject *swig_obj[1] ;
52815
52816 if (!args) SWIG_fail;
52817 swig_obj[0] = args;
52818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52819 if (!SWIG_IsOK(res1)) {
52820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52821 }
52822 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52823 {
52824 PyThreadState* __tstate = wxPyBeginAllowThreads();
52825 (arg1)->Unconstrained();
52826 wxPyEndAllowThreads(__tstate);
52827 if (PyErr_Occurred()) SWIG_fail;
52828 }
52829 resultobj = SWIG_Py_Void();
52830 return resultobj;
52831 fail:
52832 return NULL;
52833 }
52834
52835
52836 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52837 PyObject *resultobj = 0;
52838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52839 void *argp1 = 0 ;
52840 int res1 = 0 ;
52841 PyObject *swig_obj[1] ;
52842
52843 if (!args) SWIG_fail;
52844 swig_obj[0] = args;
52845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52846 if (!SWIG_IsOK(res1)) {
52847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52848 }
52849 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52850 {
52851 PyThreadState* __tstate = wxPyBeginAllowThreads();
52852 (arg1)->AsIs();
52853 wxPyEndAllowThreads(__tstate);
52854 if (PyErr_Occurred()) SWIG_fail;
52855 }
52856 resultobj = SWIG_Py_Void();
52857 return resultobj;
52858 fail:
52859 return NULL;
52860 }
52861
52862
52863 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52864 PyObject *resultobj = 0;
52865 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52866 wxWindow *result = 0 ;
52867 void *argp1 = 0 ;
52868 int res1 = 0 ;
52869 PyObject *swig_obj[1] ;
52870
52871 if (!args) SWIG_fail;
52872 swig_obj[0] = args;
52873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52874 if (!SWIG_IsOK(res1)) {
52875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52876 }
52877 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52878 {
52879 PyThreadState* __tstate = wxPyBeginAllowThreads();
52880 result = (wxWindow *)(arg1)->GetOtherWindow();
52881 wxPyEndAllowThreads(__tstate);
52882 if (PyErr_Occurred()) SWIG_fail;
52883 }
52884 {
52885 resultobj = wxPyMake_wxObject(result, 0);
52886 }
52887 return resultobj;
52888 fail:
52889 return NULL;
52890 }
52891
52892
52893 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52894 PyObject *resultobj = 0;
52895 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52896 wxEdge result;
52897 void *argp1 = 0 ;
52898 int res1 = 0 ;
52899 PyObject *swig_obj[1] ;
52900
52901 if (!args) SWIG_fail;
52902 swig_obj[0] = args;
52903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52904 if (!SWIG_IsOK(res1)) {
52905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52906 }
52907 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52908 {
52909 PyThreadState* __tstate = wxPyBeginAllowThreads();
52910 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52911 wxPyEndAllowThreads(__tstate);
52912 if (PyErr_Occurred()) SWIG_fail;
52913 }
52914 resultobj = SWIG_From_int(static_cast< int >(result));
52915 return resultobj;
52916 fail:
52917 return NULL;
52918 }
52919
52920
52921 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52922 PyObject *resultobj = 0;
52923 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52924 wxEdge arg2 ;
52925 void *argp1 = 0 ;
52926 int res1 = 0 ;
52927 int val2 ;
52928 int ecode2 = 0 ;
52929 PyObject * obj0 = 0 ;
52930 PyObject * obj1 = 0 ;
52931 char * kwnames[] = {
52932 (char *) "self",(char *) "which", NULL
52933 };
52934
52935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52937 if (!SWIG_IsOK(res1)) {
52938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52939 }
52940 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52941 ecode2 = SWIG_AsVal_int(obj1, &val2);
52942 if (!SWIG_IsOK(ecode2)) {
52943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52944 }
52945 arg2 = static_cast< wxEdge >(val2);
52946 {
52947 PyThreadState* __tstate = wxPyBeginAllowThreads();
52948 (arg1)->SetEdge(arg2);
52949 wxPyEndAllowThreads(__tstate);
52950 if (PyErr_Occurred()) SWIG_fail;
52951 }
52952 resultobj = SWIG_Py_Void();
52953 return resultobj;
52954 fail:
52955 return NULL;
52956 }
52957
52958
52959 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52960 PyObject *resultobj = 0;
52961 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52962 int arg2 ;
52963 void *argp1 = 0 ;
52964 int res1 = 0 ;
52965 int val2 ;
52966 int ecode2 = 0 ;
52967 PyObject * obj0 = 0 ;
52968 PyObject * obj1 = 0 ;
52969 char * kwnames[] = {
52970 (char *) "self",(char *) "v", NULL
52971 };
52972
52973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52975 if (!SWIG_IsOK(res1)) {
52976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52977 }
52978 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52979 ecode2 = SWIG_AsVal_int(obj1, &val2);
52980 if (!SWIG_IsOK(ecode2)) {
52981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52982 }
52983 arg2 = static_cast< int >(val2);
52984 {
52985 PyThreadState* __tstate = wxPyBeginAllowThreads();
52986 (arg1)->SetValue(arg2);
52987 wxPyEndAllowThreads(__tstate);
52988 if (PyErr_Occurred()) SWIG_fail;
52989 }
52990 resultobj = SWIG_Py_Void();
52991 return resultobj;
52992 fail:
52993 return NULL;
52994 }
52995
52996
52997 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52998 PyObject *resultobj = 0;
52999 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53000 int result;
53001 void *argp1 = 0 ;
53002 int res1 = 0 ;
53003 PyObject *swig_obj[1] ;
53004
53005 if (!args) SWIG_fail;
53006 swig_obj[0] = args;
53007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53008 if (!SWIG_IsOK(res1)) {
53009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53010 }
53011 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53012 {
53013 PyThreadState* __tstate = wxPyBeginAllowThreads();
53014 result = (int)(arg1)->GetMargin();
53015 wxPyEndAllowThreads(__tstate);
53016 if (PyErr_Occurred()) SWIG_fail;
53017 }
53018 resultobj = SWIG_From_int(static_cast< int >(result));
53019 return resultobj;
53020 fail:
53021 return NULL;
53022 }
53023
53024
53025 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53026 PyObject *resultobj = 0;
53027 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53028 int arg2 ;
53029 void *argp1 = 0 ;
53030 int res1 = 0 ;
53031 int val2 ;
53032 int ecode2 = 0 ;
53033 PyObject * obj0 = 0 ;
53034 PyObject * obj1 = 0 ;
53035 char * kwnames[] = {
53036 (char *) "self",(char *) "m", NULL
53037 };
53038
53039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53041 if (!SWIG_IsOK(res1)) {
53042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53043 }
53044 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53045 ecode2 = SWIG_AsVal_int(obj1, &val2);
53046 if (!SWIG_IsOK(ecode2)) {
53047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53048 }
53049 arg2 = static_cast< int >(val2);
53050 {
53051 PyThreadState* __tstate = wxPyBeginAllowThreads();
53052 (arg1)->SetMargin(arg2);
53053 wxPyEndAllowThreads(__tstate);
53054 if (PyErr_Occurred()) SWIG_fail;
53055 }
53056 resultobj = SWIG_Py_Void();
53057 return resultobj;
53058 fail:
53059 return NULL;
53060 }
53061
53062
53063 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53064 PyObject *resultobj = 0;
53065 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53066 int result;
53067 void *argp1 = 0 ;
53068 int res1 = 0 ;
53069 PyObject *swig_obj[1] ;
53070
53071 if (!args) SWIG_fail;
53072 swig_obj[0] = args;
53073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53074 if (!SWIG_IsOK(res1)) {
53075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53076 }
53077 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53078 {
53079 PyThreadState* __tstate = wxPyBeginAllowThreads();
53080 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53081 wxPyEndAllowThreads(__tstate);
53082 if (PyErr_Occurred()) SWIG_fail;
53083 }
53084 resultobj = SWIG_From_int(static_cast< int >(result));
53085 return resultobj;
53086 fail:
53087 return NULL;
53088 }
53089
53090
53091 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53092 PyObject *resultobj = 0;
53093 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53094 int result;
53095 void *argp1 = 0 ;
53096 int res1 = 0 ;
53097 PyObject *swig_obj[1] ;
53098
53099 if (!args) SWIG_fail;
53100 swig_obj[0] = args;
53101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53102 if (!SWIG_IsOK(res1)) {
53103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53104 }
53105 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53106 {
53107 PyThreadState* __tstate = wxPyBeginAllowThreads();
53108 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53109 wxPyEndAllowThreads(__tstate);
53110 if (PyErr_Occurred()) SWIG_fail;
53111 }
53112 resultobj = SWIG_From_int(static_cast< int >(result));
53113 return resultobj;
53114 fail:
53115 return NULL;
53116 }
53117
53118
53119 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53120 PyObject *resultobj = 0;
53121 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53122 int result;
53123 void *argp1 = 0 ;
53124 int res1 = 0 ;
53125 PyObject *swig_obj[1] ;
53126
53127 if (!args) SWIG_fail;
53128 swig_obj[0] = args;
53129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53130 if (!SWIG_IsOK(res1)) {
53131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53132 }
53133 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53134 {
53135 PyThreadState* __tstate = wxPyBeginAllowThreads();
53136 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53137 wxPyEndAllowThreads(__tstate);
53138 if (PyErr_Occurred()) SWIG_fail;
53139 }
53140 resultobj = SWIG_From_int(static_cast< int >(result));
53141 return resultobj;
53142 fail:
53143 return NULL;
53144 }
53145
53146
53147 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53148 PyObject *resultobj = 0;
53149 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53150 bool result;
53151 void *argp1 = 0 ;
53152 int res1 = 0 ;
53153 PyObject *swig_obj[1] ;
53154
53155 if (!args) SWIG_fail;
53156 swig_obj[0] = args;
53157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53158 if (!SWIG_IsOK(res1)) {
53159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53160 }
53161 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53162 {
53163 PyThreadState* __tstate = wxPyBeginAllowThreads();
53164 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53165 wxPyEndAllowThreads(__tstate);
53166 if (PyErr_Occurred()) SWIG_fail;
53167 }
53168 {
53169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53170 }
53171 return resultobj;
53172 fail:
53173 return NULL;
53174 }
53175
53176
53177 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53178 PyObject *resultobj = 0;
53179 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53180 bool arg2 ;
53181 void *argp1 = 0 ;
53182 int res1 = 0 ;
53183 bool val2 ;
53184 int ecode2 = 0 ;
53185 PyObject * obj0 = 0 ;
53186 PyObject * obj1 = 0 ;
53187 char * kwnames[] = {
53188 (char *) "self",(char *) "d", NULL
53189 };
53190
53191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53193 if (!SWIG_IsOK(res1)) {
53194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53195 }
53196 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53197 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53198 if (!SWIG_IsOK(ecode2)) {
53199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53200 }
53201 arg2 = static_cast< bool >(val2);
53202 {
53203 PyThreadState* __tstate = wxPyBeginAllowThreads();
53204 (arg1)->SetDone(arg2);
53205 wxPyEndAllowThreads(__tstate);
53206 if (PyErr_Occurred()) SWIG_fail;
53207 }
53208 resultobj = SWIG_Py_Void();
53209 return resultobj;
53210 fail:
53211 return NULL;
53212 }
53213
53214
53215 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53216 PyObject *resultobj = 0;
53217 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53218 wxRelationship result;
53219 void *argp1 = 0 ;
53220 int res1 = 0 ;
53221 PyObject *swig_obj[1] ;
53222
53223 if (!args) SWIG_fail;
53224 swig_obj[0] = args;
53225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53226 if (!SWIG_IsOK(res1)) {
53227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53228 }
53229 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53230 {
53231 PyThreadState* __tstate = wxPyBeginAllowThreads();
53232 result = (wxRelationship)(arg1)->GetRelationship();
53233 wxPyEndAllowThreads(__tstate);
53234 if (PyErr_Occurred()) SWIG_fail;
53235 }
53236 resultobj = SWIG_From_int(static_cast< int >(result));
53237 return resultobj;
53238 fail:
53239 return NULL;
53240 }
53241
53242
53243 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53244 PyObject *resultobj = 0;
53245 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53246 wxRelationship arg2 ;
53247 void *argp1 = 0 ;
53248 int res1 = 0 ;
53249 int val2 ;
53250 int ecode2 = 0 ;
53251 PyObject * obj0 = 0 ;
53252 PyObject * obj1 = 0 ;
53253 char * kwnames[] = {
53254 (char *) "self",(char *) "r", NULL
53255 };
53256
53257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53259 if (!SWIG_IsOK(res1)) {
53260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53261 }
53262 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53263 ecode2 = SWIG_AsVal_int(obj1, &val2);
53264 if (!SWIG_IsOK(ecode2)) {
53265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53266 }
53267 arg2 = static_cast< wxRelationship >(val2);
53268 {
53269 PyThreadState* __tstate = wxPyBeginAllowThreads();
53270 (arg1)->SetRelationship(arg2);
53271 wxPyEndAllowThreads(__tstate);
53272 if (PyErr_Occurred()) SWIG_fail;
53273 }
53274 resultobj = SWIG_Py_Void();
53275 return resultobj;
53276 fail:
53277 return NULL;
53278 }
53279
53280
53281 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53282 PyObject *resultobj = 0;
53283 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53284 wxWindow *arg2 = (wxWindow *) 0 ;
53285 bool result;
53286 void *argp1 = 0 ;
53287 int res1 = 0 ;
53288 void *argp2 = 0 ;
53289 int res2 = 0 ;
53290 PyObject * obj0 = 0 ;
53291 PyObject * obj1 = 0 ;
53292 char * kwnames[] = {
53293 (char *) "self",(char *) "otherW", NULL
53294 };
53295
53296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53298 if (!SWIG_IsOK(res1)) {
53299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53300 }
53301 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53303 if (!SWIG_IsOK(res2)) {
53304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53305 }
53306 arg2 = reinterpret_cast< wxWindow * >(argp2);
53307 {
53308 PyThreadState* __tstate = wxPyBeginAllowThreads();
53309 result = (bool)(arg1)->ResetIfWin(arg2);
53310 wxPyEndAllowThreads(__tstate);
53311 if (PyErr_Occurred()) SWIG_fail;
53312 }
53313 {
53314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53315 }
53316 return resultobj;
53317 fail:
53318 return NULL;
53319 }
53320
53321
53322 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53323 PyObject *resultobj = 0;
53324 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53325 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53326 wxWindow *arg3 = (wxWindow *) 0 ;
53327 bool result;
53328 void *argp1 = 0 ;
53329 int res1 = 0 ;
53330 void *argp2 = 0 ;
53331 int res2 = 0 ;
53332 void *argp3 = 0 ;
53333 int res3 = 0 ;
53334 PyObject * obj0 = 0 ;
53335 PyObject * obj1 = 0 ;
53336 PyObject * obj2 = 0 ;
53337 char * kwnames[] = {
53338 (char *) "self",(char *) "constraints",(char *) "win", NULL
53339 };
53340
53341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53343 if (!SWIG_IsOK(res1)) {
53344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53345 }
53346 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53348 if (!SWIG_IsOK(res2)) {
53349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53350 }
53351 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53352 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53353 if (!SWIG_IsOK(res3)) {
53354 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53355 }
53356 arg3 = reinterpret_cast< wxWindow * >(argp3);
53357 {
53358 PyThreadState* __tstate = wxPyBeginAllowThreads();
53359 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53360 wxPyEndAllowThreads(__tstate);
53361 if (PyErr_Occurred()) SWIG_fail;
53362 }
53363 {
53364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53365 }
53366 return resultobj;
53367 fail:
53368 return NULL;
53369 }
53370
53371
53372 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53373 PyObject *resultobj = 0;
53374 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53375 wxEdge arg2 ;
53376 wxWindow *arg3 = (wxWindow *) 0 ;
53377 wxWindow *arg4 = (wxWindow *) 0 ;
53378 int result;
53379 void *argp1 = 0 ;
53380 int res1 = 0 ;
53381 int val2 ;
53382 int ecode2 = 0 ;
53383 void *argp3 = 0 ;
53384 int res3 = 0 ;
53385 void *argp4 = 0 ;
53386 int res4 = 0 ;
53387 PyObject * obj0 = 0 ;
53388 PyObject * obj1 = 0 ;
53389 PyObject * obj2 = 0 ;
53390 PyObject * obj3 = 0 ;
53391 char * kwnames[] = {
53392 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53393 };
53394
53395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53397 if (!SWIG_IsOK(res1)) {
53398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53399 }
53400 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53401 ecode2 = SWIG_AsVal_int(obj1, &val2);
53402 if (!SWIG_IsOK(ecode2)) {
53403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53404 }
53405 arg2 = static_cast< wxEdge >(val2);
53406 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53407 if (!SWIG_IsOK(res3)) {
53408 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53409 }
53410 arg3 = reinterpret_cast< wxWindow * >(argp3);
53411 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53412 if (!SWIG_IsOK(res4)) {
53413 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53414 }
53415 arg4 = reinterpret_cast< wxWindow * >(argp4);
53416 {
53417 PyThreadState* __tstate = wxPyBeginAllowThreads();
53418 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53419 wxPyEndAllowThreads(__tstate);
53420 if (PyErr_Occurred()) SWIG_fail;
53421 }
53422 resultobj = SWIG_From_int(static_cast< int >(result));
53423 return resultobj;
53424 fail:
53425 return NULL;
53426 }
53427
53428
53429 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53430 PyObject *obj;
53431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53432 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53433 return SWIG_Py_Void();
53434 }
53435
53436 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53437 PyObject *resultobj = 0;
53438 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53439 wxIndividualLayoutConstraint *result = 0 ;
53440 void *argp1 = 0 ;
53441 int res1 = 0 ;
53442 PyObject *swig_obj[1] ;
53443
53444 if (!args) SWIG_fail;
53445 swig_obj[0] = args;
53446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53447 if (!SWIG_IsOK(res1)) {
53448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53449 }
53450 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53451 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53453 return resultobj;
53454 fail:
53455 return NULL;
53456 }
53457
53458
53459 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53460 PyObject *resultobj = 0;
53461 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53462 wxIndividualLayoutConstraint *result = 0 ;
53463 void *argp1 = 0 ;
53464 int res1 = 0 ;
53465 PyObject *swig_obj[1] ;
53466
53467 if (!args) SWIG_fail;
53468 swig_obj[0] = args;
53469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53470 if (!SWIG_IsOK(res1)) {
53471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53472 }
53473 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53474 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53476 return resultobj;
53477 fail:
53478 return NULL;
53479 }
53480
53481
53482 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53483 PyObject *resultobj = 0;
53484 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53485 wxIndividualLayoutConstraint *result = 0 ;
53486 void *argp1 = 0 ;
53487 int res1 = 0 ;
53488 PyObject *swig_obj[1] ;
53489
53490 if (!args) SWIG_fail;
53491 swig_obj[0] = args;
53492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53493 if (!SWIG_IsOK(res1)) {
53494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53495 }
53496 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53497 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53499 return resultobj;
53500 fail:
53501 return NULL;
53502 }
53503
53504
53505 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53506 PyObject *resultobj = 0;
53507 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53508 wxIndividualLayoutConstraint *result = 0 ;
53509 void *argp1 = 0 ;
53510 int res1 = 0 ;
53511 PyObject *swig_obj[1] ;
53512
53513 if (!args) SWIG_fail;
53514 swig_obj[0] = args;
53515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53516 if (!SWIG_IsOK(res1)) {
53517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53518 }
53519 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53520 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53522 return resultobj;
53523 fail:
53524 return NULL;
53525 }
53526
53527
53528 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53529 PyObject *resultobj = 0;
53530 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53531 wxIndividualLayoutConstraint *result = 0 ;
53532 void *argp1 = 0 ;
53533 int res1 = 0 ;
53534 PyObject *swig_obj[1] ;
53535
53536 if (!args) SWIG_fail;
53537 swig_obj[0] = args;
53538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53539 if (!SWIG_IsOK(res1)) {
53540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53541 }
53542 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53543 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53545 return resultobj;
53546 fail:
53547 return NULL;
53548 }
53549
53550
53551 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53552 PyObject *resultobj = 0;
53553 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53554 wxIndividualLayoutConstraint *result = 0 ;
53555 void *argp1 = 0 ;
53556 int res1 = 0 ;
53557 PyObject *swig_obj[1] ;
53558
53559 if (!args) SWIG_fail;
53560 swig_obj[0] = args;
53561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53562 if (!SWIG_IsOK(res1)) {
53563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53564 }
53565 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53566 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53568 return resultobj;
53569 fail:
53570 return NULL;
53571 }
53572
53573
53574 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53575 PyObject *resultobj = 0;
53576 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53577 wxIndividualLayoutConstraint *result = 0 ;
53578 void *argp1 = 0 ;
53579 int res1 = 0 ;
53580 PyObject *swig_obj[1] ;
53581
53582 if (!args) SWIG_fail;
53583 swig_obj[0] = args;
53584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53585 if (!SWIG_IsOK(res1)) {
53586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53587 }
53588 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53589 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53591 return resultobj;
53592 fail:
53593 return NULL;
53594 }
53595
53596
53597 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53598 PyObject *resultobj = 0;
53599 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53600 wxIndividualLayoutConstraint *result = 0 ;
53601 void *argp1 = 0 ;
53602 int res1 = 0 ;
53603 PyObject *swig_obj[1] ;
53604
53605 if (!args) SWIG_fail;
53606 swig_obj[0] = args;
53607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53608 if (!SWIG_IsOK(res1)) {
53609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53610 }
53611 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53612 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53614 return resultobj;
53615 fail:
53616 return NULL;
53617 }
53618
53619
53620 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53621 PyObject *resultobj = 0;
53622 wxLayoutConstraints *result = 0 ;
53623
53624 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53625 {
53626 PyThreadState* __tstate = wxPyBeginAllowThreads();
53627 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53628 wxPyEndAllowThreads(__tstate);
53629 if (PyErr_Occurred()) SWIG_fail;
53630 }
53631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53632 return resultobj;
53633 fail:
53634 return NULL;
53635 }
53636
53637
53638 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53639 PyObject *resultobj = 0;
53640 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53641 void *argp1 = 0 ;
53642 int res1 = 0 ;
53643 PyObject *swig_obj[1] ;
53644
53645 if (!args) SWIG_fail;
53646 swig_obj[0] = args;
53647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53648 if (!SWIG_IsOK(res1)) {
53649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53650 }
53651 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53652 {
53653 PyThreadState* __tstate = wxPyBeginAllowThreads();
53654 delete arg1;
53655
53656 wxPyEndAllowThreads(__tstate);
53657 if (PyErr_Occurred()) SWIG_fail;
53658 }
53659 resultobj = SWIG_Py_Void();
53660 return resultobj;
53661 fail:
53662 return NULL;
53663 }
53664
53665
53666 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53667 PyObject *resultobj = 0;
53668 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53669 wxWindow *arg2 = (wxWindow *) 0 ;
53670 int *arg3 = (int *) 0 ;
53671 bool result;
53672 void *argp1 = 0 ;
53673 int res1 = 0 ;
53674 void *argp2 = 0 ;
53675 int res2 = 0 ;
53676 int temp3 ;
53677 int res3 = SWIG_TMPOBJ ;
53678 PyObject * obj0 = 0 ;
53679 PyObject * obj1 = 0 ;
53680 char * kwnames[] = {
53681 (char *) "self",(char *) "win", NULL
53682 };
53683
53684 arg3 = &temp3;
53685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53687 if (!SWIG_IsOK(res1)) {
53688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53689 }
53690 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53692 if (!SWIG_IsOK(res2)) {
53693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53694 }
53695 arg2 = reinterpret_cast< wxWindow * >(argp2);
53696 {
53697 PyThreadState* __tstate = wxPyBeginAllowThreads();
53698 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53699 wxPyEndAllowThreads(__tstate);
53700 if (PyErr_Occurred()) SWIG_fail;
53701 }
53702 {
53703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53704 }
53705 if (SWIG_IsTmpObj(res3)) {
53706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53707 } else {
53708 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53710 }
53711 return resultobj;
53712 fail:
53713 return NULL;
53714 }
53715
53716
53717 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53718 PyObject *resultobj = 0;
53719 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53720 bool result;
53721 void *argp1 = 0 ;
53722 int res1 = 0 ;
53723 PyObject *swig_obj[1] ;
53724
53725 if (!args) SWIG_fail;
53726 swig_obj[0] = args;
53727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53728 if (!SWIG_IsOK(res1)) {
53729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53730 }
53731 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53732 {
53733 PyThreadState* __tstate = wxPyBeginAllowThreads();
53734 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53735 wxPyEndAllowThreads(__tstate);
53736 if (PyErr_Occurred()) SWIG_fail;
53737 }
53738 {
53739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53740 }
53741 return resultobj;
53742 fail:
53743 return NULL;
53744 }
53745
53746
53747 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53748 PyObject *obj;
53749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53750 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53751 return SWIG_Py_Void();
53752 }
53753
53754 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53755 return SWIG_Python_InitShadowInstance(args);
53756 }
53757
53758 static PyMethodDef SwigMethods[] = {
53759 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53760 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53761 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53762 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53763 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53764 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53765 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53766 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53767 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53769 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53780 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53781 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53782 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53784 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53785 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53786 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53787 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53788 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53789 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53790 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53792 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53798 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53799 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53800 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53801 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53802 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53803 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53804 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53806 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53814 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53815 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53816 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53821 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53822 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53824 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53826 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53828 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53830 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53832 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53834 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53835 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53837 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53839 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53840 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53841 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53842 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53862 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53863 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53864 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53865 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53866 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53867 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53868 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53869 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53871 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53872 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53873 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53878 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53879 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53880 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53881 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53888 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53895 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53896 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53897 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53898 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53900 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53901 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53902 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53904 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53905 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53906 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53907 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53912 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53913 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53914 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53915 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53916 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53917 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53920 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53921 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53922 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53924 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53925 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53927 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53928 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53929 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53930 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53931 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53932 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53933 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53934 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53935 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53936 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53937 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53938 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53943 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53949 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53950 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53951 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53952 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53954 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53957 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53960 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53963 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53964 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53965 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53968 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53969 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53970 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53974 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53975 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53976 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53980 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53985 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53986 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53987 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53988 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53989 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53990 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53991 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53998 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53999 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54001 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54002 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54003 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54009 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54010 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54012 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54013 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54014 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54015 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54016 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54017 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54018 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54019 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54021 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54022 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54023 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54024 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54025 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54026 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54027 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54028 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54030 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54039 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54051 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54052 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54067 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54068 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54069 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54070 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54073 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54075 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54077 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54079 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54081 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54084 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54085 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54086 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54087 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54089 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54106 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54107 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54113 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54114 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54116 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54117 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54118 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54119 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54120 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54121 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54122 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54123 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54124 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54125 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54126 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54127 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54128 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54129 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54130 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54131 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54132 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54133 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54134 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54135 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54136 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54137 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54138 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54139 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54140 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54141 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54142 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54143 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54144 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54145 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54146 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54147 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54148 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54150 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54151 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54152 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54153 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54156 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54160 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54164 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54165 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54166 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54167 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54169 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54170 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54172 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54174 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54176 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54178 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54179 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54180 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54182 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54183 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54185 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54186 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54187 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54189 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54190 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54191 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54193 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54195 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54196 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54197 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54199 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54201 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54202 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54204 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54205 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54206 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54208 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54209 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54210 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54211 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54212 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54214 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54215 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54218 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54219 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54221 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54222 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54225 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54226 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54228 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54234 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54235 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54236 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54237 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54238 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54239 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54240 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54241 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54242 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54243 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54244 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54245 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54246 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54247 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54248 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54249 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54250 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54251 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54252 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54253 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54254 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54255 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54256 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54257 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54259 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54260 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54261 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54262 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54263 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54264 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54265 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54266 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54267 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54268 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54269 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54270 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54271 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54272 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54273 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54274 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54275 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54276 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54277 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54278 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54279 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54280 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54281 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54282 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54283 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54284 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54285 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54286 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54287 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54288 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54289 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54290 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54291 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54292 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54293 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54295 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54296 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54297 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54298 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54300 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54301 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54302 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54303 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54304 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54305 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54306 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54307 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54308 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54310 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54311 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54312 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54313 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54314 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54315 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54316 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54317 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54318 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54319 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54320 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54321 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54322 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54323 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54324 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54325 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54326 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54327 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54328 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54329 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54330 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54331 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54332 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54333 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54334 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54335 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54336 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54337 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54339 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54340 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54343 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54344 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54345 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54346 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54347 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54348 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54350 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54351 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54354 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54355 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54357 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54358 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54360 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54361 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54363 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54364 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54365 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54367 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54369 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54370 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54372 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54373 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54374 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54376 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54377 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54378 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54380 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54381 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54383 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54384 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54385 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54386 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54387 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54390 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54392 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54394 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54395 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54396 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54399 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54400 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54401 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54403 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54404 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54405 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54407 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54408 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54409 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54410 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54411 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54412 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54414 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54415 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54416 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54417 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54418 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54419 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54420 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54421 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54427 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54429 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54431 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54432 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54433 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54434 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54435 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54436 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54438 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54439 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54440 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54442 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54443 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54444 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54445 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54446 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54449 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54450 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54451 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54454 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54455 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54456 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54457 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54458 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54460 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54462 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54465 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54467 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54468 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54470 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54471 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54472 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54474 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54475 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54476 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54478 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54480 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54481 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54482 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54484 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54486 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54488 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54489 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54491 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54492 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54494 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54496 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54497 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54498 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54500 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54502 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54503 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54504 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54506 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54508 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54509 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54510 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54511 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54513 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54515 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54517 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54519 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54520 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54522 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54523 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54524 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54525 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54526 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54527 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54528 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54529 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54530 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54531 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54532 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54534 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54536 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54538 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54540 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54542 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54543 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54544 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54545 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54546 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54547 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54553 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54554 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54555 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54556 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54557 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54558 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54559 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54560 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54562 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54563 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54564 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54565 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54567 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54568 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54569 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54570 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54572 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54573 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54574 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54575 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54577 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54578 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54580 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54581 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54582 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54584 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54587 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54588 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54589 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54590 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54591 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54593 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54594 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54596 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54597 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54598 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54599 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54601 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54602 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54603 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54604 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54605 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54606 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54607 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54608 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54609 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54610 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54612 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54614 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54615 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54616 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54617 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54619 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54621 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54623 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54625 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54626 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54629 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54639 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54640 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54644 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54645 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54646 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54647 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54648 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54649 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54650 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54651 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54652 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54653 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54654 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54655 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54656 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54657 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54658 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54660 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54661 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54663 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54664 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54665 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54666 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54668 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54670 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54671 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54674 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54675 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54676 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54677 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54678 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54680 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54681 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54682 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54684 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54685 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54686 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54687 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54688 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54689 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54690 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54691 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54692 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54693 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54695 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54698 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54699 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54700 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54701 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54702 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54703 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54707 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54708 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54709 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54710 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54713 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54714 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54715 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54716 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54717 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54723 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54724 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54725 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54726 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54727 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54729 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54738 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54739 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54740 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54741 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54742 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54744 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54745 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54746 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54747 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54748 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54749 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54751 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54752 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54754 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54756 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54762 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54763 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54764 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54765 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54767 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54768 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54770 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54773 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54775 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54776 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54777 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54786 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54790 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54791 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54793 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
54794 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54795 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54804 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54805 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54806 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54807 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54811 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54812 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54814 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54816 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54817 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54819 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54820 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54821 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54822 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54825 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54827 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54828 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54829 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54830 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54832 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54833 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54838 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54839 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54840 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54842 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54843 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54844 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54845 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54846 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54848 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54849 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54850 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54852 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54853 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54856 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54864 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54870 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54871 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54874 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54875 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54879 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54882 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54883 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54888 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54896 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54898 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54900 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54901 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54903 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54905 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54906 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54908 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54909 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54910 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54914 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54925 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54928 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54929 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54933 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54934 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54935 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54936 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54937 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54939 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54940 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54941 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54943 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54944 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54946 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54947 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54948 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54950 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54951 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54952 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54953 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54955 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54956 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54957 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54959 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54961 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54963 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54964 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54966 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54967 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54970 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54972 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54974 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54976 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54979 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54981 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54982 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54983 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54985 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54986 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54987 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54989 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54991 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54992 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54994 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54996 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54997 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55001 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55005 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55006 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55008 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55012 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55014 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55016 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55017 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55018 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55019 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55023 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55024 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55025 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55026 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55028 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55029 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55034 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55035 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55036 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55037 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55038 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55040 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55042 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55044 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55045 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55047 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55049 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55052 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55053 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55054 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55056 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55057 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55058 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55070 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55071 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55077 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55078 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55079 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55080 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55081 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55082 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55088 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55089 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55093 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55094 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55096 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55097 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55099 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55101 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55102 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55104 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55105 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55106 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55112 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55113 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55114 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55115 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55116 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55117 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55120 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55124 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55126 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55127 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55128 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55129 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55130 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55131 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55132 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55133 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55137 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55138 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55139 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55140 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55141 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55142 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55143 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55145 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55146 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55147 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55148 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55153 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55154 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55155 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55157 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55158 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55159 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55164 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55165 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55166 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55167 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55168 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55169 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55173 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55174 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55179 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55180 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55182 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55183 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55188 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55190 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55191 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55192 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55193 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55194 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55199 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55200 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55201 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55202 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55203 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55209 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55210 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55211 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55212 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55213 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55215 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55217 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55218 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55219 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55220 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55222 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55223 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55224 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55225 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55226 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55227 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55228 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55229 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55230 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55231 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55232 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55233 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55234 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55235 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55236 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55237 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55238 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55239 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55240 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55241 { NULL, NULL, 0, NULL }
55242 };
55243
55244
55245 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55246
55247 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55248 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55249 }
55250 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55251 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55252 }
55253 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55254 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55255 }
55256 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55257 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55258 }
55259 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55260 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55261 }
55262 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55263 return (void *)((wxSizer *) ((wxGridSizer *) x));
55264 }
55265 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55266 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55267 }
55268 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55269 return (void *)((wxSizer *) ((wxPySizer *) x));
55270 }
55271 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55272 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55273 }
55274 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55275 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55276 }
55277 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55278 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55279 }
55280 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55281 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55282 }
55283 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55284 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55285 }
55286 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55287 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55288 }
55289 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55290 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55291 }
55292 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55293 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55294 }
55295 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55296 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55297 }
55298 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55299 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55300 }
55301 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55302 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55303 }
55304 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55305 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55306 }
55307 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55308 return (void *)((wxEvent *) ((wxPyEvent *) x));
55309 }
55310 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55311 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55312 }
55313 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55314 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55315 }
55316 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55317 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55318 }
55319 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55320 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55321 }
55322 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55323 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55324 }
55325 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55326 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55327 }
55328 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55329 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55330 }
55331 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55332 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55333 }
55334 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55335 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55336 }
55337 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55338 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55339 }
55340 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55341 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55342 }
55343 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55344 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55345 }
55346 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55347 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55348 }
55349 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55350 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55351 }
55352 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55353 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55354 }
55355 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55356 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55357 }
55358 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55359 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55360 }
55361 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55362 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55363 }
55364 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55365 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55366 }
55367 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55368 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55369 }
55370 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55371 return (void *)((wxEvent *) ((wxShowEvent *) x));
55372 }
55373 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55374 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55375 }
55376 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55377 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55378 }
55379 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55380 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55381 }
55382 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55383 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55384 }
55385 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55386 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55387 }
55388 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55389 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55390 }
55391 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55392 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55393 }
55394 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55395 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55396 }
55397 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55398 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55399 }
55400 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55401 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55402 }
55403 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55404 return (void *)((wxControl *) ((wxControlWithItems *) x));
55405 }
55406 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55407 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55408 }
55409 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55410 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55411 }
55412 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55413 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55414 }
55415 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55416 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55417 }
55418 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55419 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55420 }
55421 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55422 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55423 }
55424 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55425 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55426 }
55427 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55428 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55429 }
55430 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55431 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55432 }
55433 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55434 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55435 }
55436 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55437 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55438 }
55439 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55440 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55441 }
55442 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55443 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55444 }
55445 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55446 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55447 }
55448 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55449 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55450 }
55451 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55452 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55453 }
55454 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55455 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55456 }
55457 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55458 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55459 }
55460 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55461 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55462 }
55463 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55464 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55465 }
55466 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55467 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55468 }
55469 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55470 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55471 }
55472 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55473 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55474 }
55475 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55476 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55477 }
55478 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55479 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55480 }
55481 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55482 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55483 }
55484 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55485 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55486 }
55487 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55488 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55489 }
55490 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55491 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55492 }
55493 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55494 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55495 }
55496 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55497 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55498 }
55499 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55500 return (void *)((wxObject *) ((wxSizerItem *) x));
55501 }
55502 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55503 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55504 }
55505 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55506 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55507 }
55508 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55509 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55510 }
55511 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55512 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55513 }
55514 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55515 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55516 }
55517 static void *_p_wxSizerTo_p_wxObject(void *x) {
55518 return (void *)((wxObject *) ((wxSizer *) x));
55519 }
55520 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55521 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55522 }
55523 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55524 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55525 }
55526 static void *_p_wxEventTo_p_wxObject(void *x) {
55527 return (void *)((wxObject *) ((wxEvent *) x));
55528 }
55529 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55530 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55531 }
55532 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55533 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55534 }
55535 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55536 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55537 }
55538 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55539 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55540 }
55541 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55542 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55543 }
55544 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55545 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55546 }
55547 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55548 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55549 }
55550 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55551 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55552 }
55553 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55554 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55555 }
55556 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55557 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55558 }
55559 static void *_p_wxControlTo_p_wxObject(void *x) {
55560 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55561 }
55562 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55563 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55564 }
55565 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55566 return (void *)((wxObject *) ((wxFSFile *) x));
55567 }
55568 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55569 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55570 }
55571 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55572 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55573 }
55574 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55575 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55576 }
55577 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55578 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55579 }
55580 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55581 return (void *)((wxObject *) ((wxMenuItem *) x));
55582 }
55583 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55584 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55585 }
55586 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55587 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55588 }
55589 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55590 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55591 }
55592 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55593 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55594 }
55595 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55596 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55597 }
55598 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55599 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55600 }
55601 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55602 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55603 }
55604 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55605 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55606 }
55607 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55608 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55609 }
55610 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55611 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55612 }
55613 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55614 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55615 }
55616 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55617 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55618 }
55619 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55620 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55621 }
55622 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55623 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55624 }
55625 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55626 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55627 }
55628 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55629 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55630 }
55631 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55632 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55633 }
55634 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55635 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55636 }
55637 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55638 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55639 }
55640 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55641 return (void *)((wxObject *) ((wxImageHandler *) x));
55642 }
55643 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55644 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55645 }
55646 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55647 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55648 }
55649 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55650 return (void *)((wxObject *) ((wxEvtHandler *) x));
55651 }
55652 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55653 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55654 }
55655 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55656 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55657 }
55658 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55659 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55660 }
55661 static void *_p_wxImageTo_p_wxObject(void *x) {
55662 return (void *)((wxObject *) ((wxImage *) x));
55663 }
55664 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55665 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55666 }
55667 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55668 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55669 }
55670 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55671 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55672 }
55673 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55674 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55675 }
55676 static void *_p_wxWindowTo_p_wxObject(void *x) {
55677 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55678 }
55679 static void *_p_wxMenuTo_p_wxObject(void *x) {
55680 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55681 }
55682 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55683 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55684 }
55685 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55686 return (void *)((wxObject *) ((wxFileSystem *) x));
55687 }
55688 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55689 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55690 }
55691 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55692 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55693 }
55694 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55695 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55696 }
55697 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55698 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55699 }
55700 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55701 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55702 }
55703 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55704 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55705 }
55706 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55707 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55708 }
55709 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55710 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55711 }
55712 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55713 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55714 }
55715 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55716 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55717 }
55718 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55719 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55720 }
55721 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55722 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55723 }
55724 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55725 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55726 }
55727 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55728 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55729 }
55730 static void *_p_wxControlTo_p_wxWindow(void *x) {
55731 return (void *)((wxWindow *) ((wxControl *) x));
55732 }
55733 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55734 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55735 }
55736 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55737 return (void *)((wxWindow *) ((wxMenuBar *) x));
55738 }
55739 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55740 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55741 }
55742 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55743 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55744 }
55745 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55746 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55747 }
55748 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55749 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55750 }
55751 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55752 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55753 }
55754 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55755 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55756 }
55757 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55758 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55759 }
55760 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55761 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55762 }
55763 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55764 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55765 }
55766 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55767 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55768 }
55769 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55770 return (void *)((wxValidator *) ((wxPyValidator *) x));
55771 }
55772 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55774 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};
55775 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55817 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55818 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55819 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55820 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55821 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55822 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55823 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55824 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55825 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55826 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55827 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55828 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55829 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55830 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55831 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55832 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55833 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55834 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55835 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55836 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55837 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55838 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55839 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55840 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55841 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55842 static swig_type_info _swigt__p_wxLayoutDirection = {"_p_wxLayoutDirection", "wxLayoutDirection *", 0, 0, (void*)0, 0};
55843 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55844 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55845 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55846 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55847 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55848 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55849 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55850 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55851 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55852 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55853 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55854 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55855 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55856 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55857 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55858 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55859 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55860 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55861 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55862 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55863 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55864 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55865 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55866 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55867 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55868 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55869 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55870 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55871 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55872 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55873 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55874 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55875 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55876 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55877 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55878 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55879 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55880 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55881 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55882 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55883 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55884 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55885 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55886 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55887 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55888 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55889 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55890 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55891 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55892 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55893 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55894 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55895 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55896 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55897 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55898 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55899 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55900 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55901 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55902 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55903 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55904 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55905
55906 static swig_type_info *swig_type_initial[] = {
55907 &_swigt__p_buffer,
55908 &_swigt__p_char,
55909 &_swigt__p_form_ops_t,
55910 &_swigt__p_int,
55911 &_swigt__p_long,
55912 &_swigt__p_unsigned_char,
55913 &_swigt__p_unsigned_int,
55914 &_swigt__p_unsigned_long,
55915 &_swigt__p_wxANIHandler,
55916 &_swigt__p_wxAcceleratorEntry,
55917 &_swigt__p_wxAcceleratorTable,
55918 &_swigt__p_wxActivateEvent,
55919 &_swigt__p_wxAppTraits,
55920 &_swigt__p_wxArrayString,
55921 &_swigt__p_wxBMPHandler,
55922 &_swigt__p_wxBitmap,
55923 &_swigt__p_wxBoxSizer,
55924 &_swigt__p_wxButton,
55925 &_swigt__p_wxCURHandler,
55926 &_swigt__p_wxCaret,
55927 &_swigt__p_wxChildFocusEvent,
55928 &_swigt__p_wxClipboardTextEvent,
55929 &_swigt__p_wxCloseEvent,
55930 &_swigt__p_wxColour,
55931 &_swigt__p_wxCommandEvent,
55932 &_swigt__p_wxContextMenuEvent,
55933 &_swigt__p_wxControl,
55934 &_swigt__p_wxControlWithItems,
55935 &_swigt__p_wxCursor,
55936 &_swigt__p_wxDC,
55937 &_swigt__p_wxDateEvent,
55938 &_swigt__p_wxDateTime,
55939 &_swigt__p_wxDisplayChangedEvent,
55940 &_swigt__p_wxDropFilesEvent,
55941 &_swigt__p_wxDuplexMode,
55942 &_swigt__p_wxEraseEvent,
55943 &_swigt__p_wxEvent,
55944 &_swigt__p_wxEventLoop,
55945 &_swigt__p_wxEventLoopActivator,
55946 &_swigt__p_wxEvtHandler,
55947 &_swigt__p_wxFSFile,
55948 &_swigt__p_wxFileSystem,
55949 &_swigt__p_wxFileSystemHandler,
55950 &_swigt__p_wxFlexGridSizer,
55951 &_swigt__p_wxFocusEvent,
55952 &_swigt__p_wxFont,
55953 &_swigt__p_wxFrame,
55954 &_swigt__p_wxGBPosition,
55955 &_swigt__p_wxGBSizerItem,
55956 &_swigt__p_wxGBSpan,
55957 &_swigt__p_wxGIFHandler,
55958 &_swigt__p_wxGridBagSizer,
55959 &_swigt__p_wxGridSizer,
55960 &_swigt__p_wxHelpEvent__Origin,
55961 &_swigt__p_wxICOHandler,
55962 &_swigt__p_wxIconizeEvent,
55963 &_swigt__p_wxIdleEvent,
55964 &_swigt__p_wxImage,
55965 &_swigt__p_wxImageHandler,
55966 &_swigt__p_wxImageHistogram,
55967 &_swigt__p_wxImage_HSVValue,
55968 &_swigt__p_wxImage_RGBValue,
55969 &_swigt__p_wxIndividualLayoutConstraint,
55970 &_swigt__p_wxInitDialogEvent,
55971 &_swigt__p_wxInputStream,
55972 &_swigt__p_wxInternetFSHandler,
55973 &_swigt__p_wxItemContainer,
55974 &_swigt__p_wxJPEGHandler,
55975 &_swigt__p_wxKeyEvent,
55976 &_swigt__p_wxLayoutConstraints,
55977 &_swigt__p_wxLayoutDirection,
55978 &_swigt__p_wxMaximizeEvent,
55979 &_swigt__p_wxMemoryFSHandler,
55980 &_swigt__p_wxMenu,
55981 &_swigt__p_wxMenuBar,
55982 &_swigt__p_wxMenuBarBase,
55983 &_swigt__p_wxMenuEvent,
55984 &_swigt__p_wxMenuItem,
55985 &_swigt__p_wxMouseCaptureChangedEvent,
55986 &_swigt__p_wxMouseCaptureLostEvent,
55987 &_swigt__p_wxMouseEvent,
55988 &_swigt__p_wxMoveEvent,
55989 &_swigt__p_wxNavigationKeyEvent,
55990 &_swigt__p_wxNcPaintEvent,
55991 &_swigt__p_wxNotifyEvent,
55992 &_swigt__p_wxObject,
55993 &_swigt__p_wxOutputStream,
55994 &_swigt__p_wxPCXHandler,
55995 &_swigt__p_wxPNGHandler,
55996 &_swigt__p_wxPNMHandler,
55997 &_swigt__p_wxPaintEvent,
55998 &_swigt__p_wxPaletteChangedEvent,
55999 &_swigt__p_wxPaperSize,
56000 &_swigt__p_wxPoint,
56001 &_swigt__p_wxPoint2D,
56002 &_swigt__p_wxPropagateOnce,
56003 &_swigt__p_wxPropagationDisabler,
56004 &_swigt__p_wxPyApp,
56005 &_swigt__p_wxPyCommandEvent,
56006 &_swigt__p_wxPyDropTarget,
56007 &_swigt__p_wxPyEvent,
56008 &_swigt__p_wxPyFileSystemHandler,
56009 &_swigt__p_wxPyImageHandler,
56010 &_swigt__p_wxPyInputStream,
56011 &_swigt__p_wxPySizer,
56012 &_swigt__p_wxPyValidator,
56013 &_swigt__p_wxQuantize,
56014 &_swigt__p_wxQueryNewPaletteEvent,
56015 &_swigt__p_wxRealPoint,
56016 &_swigt__p_wxRect,
56017 &_swigt__p_wxRegion,
56018 &_swigt__p_wxScrollEvent,
56019 &_swigt__p_wxScrollWinEvent,
56020 &_swigt__p_wxSetCursorEvent,
56021 &_swigt__p_wxShowEvent,
56022 &_swigt__p_wxSize,
56023 &_swigt__p_wxSizeEvent,
56024 &_swigt__p_wxSizer,
56025 &_swigt__p_wxSizerItem,
56026 &_swigt__p_wxStaticBox,
56027 &_swigt__p_wxStaticBoxSizer,
56028 &_swigt__p_wxStdDialogButtonSizer,
56029 &_swigt__p_wxSysColourChangedEvent,
56030 &_swigt__p_wxTIFFHandler,
56031 &_swigt__p_wxToolTip,
56032 &_swigt__p_wxUpdateUIEvent,
56033 &_swigt__p_wxValidator,
56034 &_swigt__p_wxVisualAttributes,
56035 &_swigt__p_wxWindow,
56036 &_swigt__p_wxWindowCreateEvent,
56037 &_swigt__p_wxWindowDestroyEvent,
56038 &_swigt__p_wxXPMHandler,
56039 &_swigt__p_wxZipFSHandler,
56040 };
56041
56042 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56043 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56044 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56045 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56046 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56047 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56048 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56049 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56055 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56056 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}};
56057 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56058 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}};
56059 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56060 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}};
56061 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56063 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56066 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}};
56067 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56068 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}};
56069 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56070 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56071 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56072 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56073 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56074 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56075 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56078 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}};
56079 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56080 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56081 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}};
56082 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56083 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56084 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}};
56085 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}};
56086 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56087 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56088 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56089 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56090 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56091 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56092 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56093 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56094 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}};
56095 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56096 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}};
56097 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56098 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56099 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56100 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}};
56101 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56102 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56103 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56104 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56105 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56106 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56107 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56108 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}};
56109 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56110 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56111 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56112 static swig_cast_info _swigc__p_wxLayoutDirection[] = { {&_swigt__p_wxLayoutDirection, 0, 0, 0},{0, 0, 0, 0}};
56113 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56114 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56115 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56116 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56117 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56118 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56119 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56120 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56121 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56122 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56123 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56124 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56125 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56126 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56127 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}};
56128 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56129 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56130 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56131 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56132 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56133 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56134 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56135 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56136 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56137 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56138 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56139 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56140 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56141 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56142 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56143 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56144 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56145 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56146 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56147 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56148 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56149 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56150 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56151 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56152 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56153 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56154 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56155 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56156 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56157 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56158 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56159 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}};
56160 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}};
56161 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56162 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56163 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56164 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56165 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56166 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56167 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56168 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}};
56169 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56170 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}};
56171 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56172 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56173 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56174 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56175
56176 static swig_cast_info *swig_cast_initial[] = {
56177 _swigc__p_buffer,
56178 _swigc__p_char,
56179 _swigc__p_form_ops_t,
56180 _swigc__p_int,
56181 _swigc__p_long,
56182 _swigc__p_unsigned_char,
56183 _swigc__p_unsigned_int,
56184 _swigc__p_unsigned_long,
56185 _swigc__p_wxANIHandler,
56186 _swigc__p_wxAcceleratorEntry,
56187 _swigc__p_wxAcceleratorTable,
56188 _swigc__p_wxActivateEvent,
56189 _swigc__p_wxAppTraits,
56190 _swigc__p_wxArrayString,
56191 _swigc__p_wxBMPHandler,
56192 _swigc__p_wxBitmap,
56193 _swigc__p_wxBoxSizer,
56194 _swigc__p_wxButton,
56195 _swigc__p_wxCURHandler,
56196 _swigc__p_wxCaret,
56197 _swigc__p_wxChildFocusEvent,
56198 _swigc__p_wxClipboardTextEvent,
56199 _swigc__p_wxCloseEvent,
56200 _swigc__p_wxColour,
56201 _swigc__p_wxCommandEvent,
56202 _swigc__p_wxContextMenuEvent,
56203 _swigc__p_wxControl,
56204 _swigc__p_wxControlWithItems,
56205 _swigc__p_wxCursor,
56206 _swigc__p_wxDC,
56207 _swigc__p_wxDateEvent,
56208 _swigc__p_wxDateTime,
56209 _swigc__p_wxDisplayChangedEvent,
56210 _swigc__p_wxDropFilesEvent,
56211 _swigc__p_wxDuplexMode,
56212 _swigc__p_wxEraseEvent,
56213 _swigc__p_wxEvent,
56214 _swigc__p_wxEventLoop,
56215 _swigc__p_wxEventLoopActivator,
56216 _swigc__p_wxEvtHandler,
56217 _swigc__p_wxFSFile,
56218 _swigc__p_wxFileSystem,
56219 _swigc__p_wxFileSystemHandler,
56220 _swigc__p_wxFlexGridSizer,
56221 _swigc__p_wxFocusEvent,
56222 _swigc__p_wxFont,
56223 _swigc__p_wxFrame,
56224 _swigc__p_wxGBPosition,
56225 _swigc__p_wxGBSizerItem,
56226 _swigc__p_wxGBSpan,
56227 _swigc__p_wxGIFHandler,
56228 _swigc__p_wxGridBagSizer,
56229 _swigc__p_wxGridSizer,
56230 _swigc__p_wxHelpEvent__Origin,
56231 _swigc__p_wxICOHandler,
56232 _swigc__p_wxIconizeEvent,
56233 _swigc__p_wxIdleEvent,
56234 _swigc__p_wxImage,
56235 _swigc__p_wxImageHandler,
56236 _swigc__p_wxImageHistogram,
56237 _swigc__p_wxImage_HSVValue,
56238 _swigc__p_wxImage_RGBValue,
56239 _swigc__p_wxIndividualLayoutConstraint,
56240 _swigc__p_wxInitDialogEvent,
56241 _swigc__p_wxInputStream,
56242 _swigc__p_wxInternetFSHandler,
56243 _swigc__p_wxItemContainer,
56244 _swigc__p_wxJPEGHandler,
56245 _swigc__p_wxKeyEvent,
56246 _swigc__p_wxLayoutConstraints,
56247 _swigc__p_wxLayoutDirection,
56248 _swigc__p_wxMaximizeEvent,
56249 _swigc__p_wxMemoryFSHandler,
56250 _swigc__p_wxMenu,
56251 _swigc__p_wxMenuBar,
56252 _swigc__p_wxMenuBarBase,
56253 _swigc__p_wxMenuEvent,
56254 _swigc__p_wxMenuItem,
56255 _swigc__p_wxMouseCaptureChangedEvent,
56256 _swigc__p_wxMouseCaptureLostEvent,
56257 _swigc__p_wxMouseEvent,
56258 _swigc__p_wxMoveEvent,
56259 _swigc__p_wxNavigationKeyEvent,
56260 _swigc__p_wxNcPaintEvent,
56261 _swigc__p_wxNotifyEvent,
56262 _swigc__p_wxObject,
56263 _swigc__p_wxOutputStream,
56264 _swigc__p_wxPCXHandler,
56265 _swigc__p_wxPNGHandler,
56266 _swigc__p_wxPNMHandler,
56267 _swigc__p_wxPaintEvent,
56268 _swigc__p_wxPaletteChangedEvent,
56269 _swigc__p_wxPaperSize,
56270 _swigc__p_wxPoint,
56271 _swigc__p_wxPoint2D,
56272 _swigc__p_wxPropagateOnce,
56273 _swigc__p_wxPropagationDisabler,
56274 _swigc__p_wxPyApp,
56275 _swigc__p_wxPyCommandEvent,
56276 _swigc__p_wxPyDropTarget,
56277 _swigc__p_wxPyEvent,
56278 _swigc__p_wxPyFileSystemHandler,
56279 _swigc__p_wxPyImageHandler,
56280 _swigc__p_wxPyInputStream,
56281 _swigc__p_wxPySizer,
56282 _swigc__p_wxPyValidator,
56283 _swigc__p_wxQuantize,
56284 _swigc__p_wxQueryNewPaletteEvent,
56285 _swigc__p_wxRealPoint,
56286 _swigc__p_wxRect,
56287 _swigc__p_wxRegion,
56288 _swigc__p_wxScrollEvent,
56289 _swigc__p_wxScrollWinEvent,
56290 _swigc__p_wxSetCursorEvent,
56291 _swigc__p_wxShowEvent,
56292 _swigc__p_wxSize,
56293 _swigc__p_wxSizeEvent,
56294 _swigc__p_wxSizer,
56295 _swigc__p_wxSizerItem,
56296 _swigc__p_wxStaticBox,
56297 _swigc__p_wxStaticBoxSizer,
56298 _swigc__p_wxStdDialogButtonSizer,
56299 _swigc__p_wxSysColourChangedEvent,
56300 _swigc__p_wxTIFFHandler,
56301 _swigc__p_wxToolTip,
56302 _swigc__p_wxUpdateUIEvent,
56303 _swigc__p_wxValidator,
56304 _swigc__p_wxVisualAttributes,
56305 _swigc__p_wxWindow,
56306 _swigc__p_wxWindowCreateEvent,
56307 _swigc__p_wxWindowDestroyEvent,
56308 _swigc__p_wxXPMHandler,
56309 _swigc__p_wxZipFSHandler,
56310 };
56311
56312
56313 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56314
56315 static swig_const_info swig_const_table[] = {
56316 {0, 0, 0, 0.0, 0, 0}};
56317
56318 #ifdef __cplusplus
56319 }
56320 #endif
56321 /* -----------------------------------------------------------------------------
56322 * Type initialization:
56323 * This problem is tough by the requirement that no dynamic
56324 * memory is used. Also, since swig_type_info structures store pointers to
56325 * swig_cast_info structures and swig_cast_info structures store pointers back
56326 * to swig_type_info structures, we need some lookup code at initialization.
56327 * The idea is that swig generates all the structures that are needed.
56328 * The runtime then collects these partially filled structures.
56329 * The SWIG_InitializeModule function takes these initial arrays out of
56330 * swig_module, and does all the lookup, filling in the swig_module.types
56331 * array with the correct data and linking the correct swig_cast_info
56332 * structures together.
56333 *
56334 * The generated swig_type_info structures are assigned staticly to an initial
56335 * array. We just loop though that array, and handle each type individually.
56336 * First we lookup if this type has been already loaded, and if so, use the
56337 * loaded structure instead of the generated one. Then we have to fill in the
56338 * cast linked list. The cast data is initially stored in something like a
56339 * two-dimensional array. Each row corresponds to a type (there are the same
56340 * number of rows as there are in the swig_type_initial array). Each entry in
56341 * a column is one of the swig_cast_info structures for that type.
56342 * The cast_initial array is actually an array of arrays, because each row has
56343 * a variable number of columns. So to actually build the cast linked list,
56344 * we find the array of casts associated with the type, and loop through it
56345 * adding the casts to the list. The one last trick we need to do is making
56346 * sure the type pointer in the swig_cast_info struct is correct.
56347 *
56348 * First off, we lookup the cast->type name to see if it is already loaded.
56349 * There are three cases to handle:
56350 * 1) If the cast->type has already been loaded AND the type we are adding
56351 * casting info to has not been loaded (it is in this module), THEN we
56352 * replace the cast->type pointer with the type pointer that has already
56353 * been loaded.
56354 * 2) If BOTH types (the one we are adding casting info to, and the
56355 * cast->type) are loaded, THEN the cast info has already been loaded by
56356 * the previous module so we just ignore it.
56357 * 3) Finally, if cast->type has not already been loaded, then we add that
56358 * swig_cast_info to the linked list (because the cast->type) pointer will
56359 * be correct.
56360 * ----------------------------------------------------------------------------- */
56361
56362 #ifdef __cplusplus
56363 extern "C" {
56364 #if 0
56365 } /* c-mode */
56366 #endif
56367 #endif
56368
56369 #if 0
56370 #define SWIGRUNTIME_DEBUG
56371 #endif
56372
56373 SWIGRUNTIME void
56374 SWIG_InitializeModule(void *clientdata) {
56375 size_t i;
56376 swig_module_info *module_head;
56377 static int init_run = 0;
56378
56379 clientdata = clientdata;
56380
56381 if (init_run) return;
56382 init_run = 1;
56383
56384 /* Initialize the swig_module */
56385 swig_module.type_initial = swig_type_initial;
56386 swig_module.cast_initial = swig_cast_initial;
56387
56388 /* Try and load any already created modules */
56389 module_head = SWIG_GetModule(clientdata);
56390 if (module_head) {
56391 swig_module.next = module_head->next;
56392 module_head->next = &swig_module;
56393 } else {
56394 /* This is the first module loaded */
56395 swig_module.next = &swig_module;
56396 SWIG_SetModule(clientdata, &swig_module);
56397 }
56398
56399 /* Now work on filling in swig_module.types */
56400 #ifdef SWIGRUNTIME_DEBUG
56401 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56402 #endif
56403 for (i = 0; i < swig_module.size; ++i) {
56404 swig_type_info *type = 0;
56405 swig_type_info *ret;
56406 swig_cast_info *cast;
56407
56408 #ifdef SWIGRUNTIME_DEBUG
56409 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56410 #endif
56411
56412 /* if there is another module already loaded */
56413 if (swig_module.next != &swig_module) {
56414 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56415 }
56416 if (type) {
56417 /* Overwrite clientdata field */
56418 #ifdef SWIGRUNTIME_DEBUG
56419 printf("SWIG_InitializeModule: found type %s\n", type->name);
56420 #endif
56421 if (swig_module.type_initial[i]->clientdata) {
56422 type->clientdata = swig_module.type_initial[i]->clientdata;
56423 #ifdef SWIGRUNTIME_DEBUG
56424 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56425 #endif
56426 }
56427 } else {
56428 type = swig_module.type_initial[i];
56429 }
56430
56431 /* Insert casting types */
56432 cast = swig_module.cast_initial[i];
56433 while (cast->type) {
56434 /* Don't need to add information already in the list */
56435 ret = 0;
56436 #ifdef SWIGRUNTIME_DEBUG
56437 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56438 #endif
56439 if (swig_module.next != &swig_module) {
56440 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56441 #ifdef SWIGRUNTIME_DEBUG
56442 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56443 #endif
56444 }
56445 if (ret) {
56446 if (type == swig_module.type_initial[i]) {
56447 #ifdef SWIGRUNTIME_DEBUG
56448 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56449 #endif
56450 cast->type = ret;
56451 ret = 0;
56452 } else {
56453 /* Check for casting already in the list */
56454 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56455 #ifdef SWIGRUNTIME_DEBUG
56456 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56457 #endif
56458 if (!ocast) ret = 0;
56459 }
56460 }
56461
56462 if (!ret) {
56463 #ifdef SWIGRUNTIME_DEBUG
56464 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56465 #endif
56466 if (type->cast) {
56467 type->cast->prev = cast;
56468 cast->next = type->cast;
56469 }
56470 type->cast = cast;
56471 }
56472 cast++;
56473 }
56474 /* Set entry in modules->types array equal to the type */
56475 swig_module.types[i] = type;
56476 }
56477 swig_module.types[i] = 0;
56478
56479 #ifdef SWIGRUNTIME_DEBUG
56480 printf("**** SWIG_InitializeModule: Cast List ******\n");
56481 for (i = 0; i < swig_module.size; ++i) {
56482 int j = 0;
56483 swig_cast_info *cast = swig_module.cast_initial[i];
56484 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56485 while (cast->type) {
56486 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56487 cast++;
56488 ++j;
56489 }
56490 printf("---- Total casts: %d\n",j);
56491 }
56492 printf("**** SWIG_InitializeModule: Cast List ******\n");
56493 #endif
56494 }
56495
56496 /* This function will propagate the clientdata field of type to
56497 * any new swig_type_info structures that have been added into the list
56498 * of equivalent types. It is like calling
56499 * SWIG_TypeClientData(type, clientdata) a second time.
56500 */
56501 SWIGRUNTIME void
56502 SWIG_PropagateClientData(void) {
56503 size_t i;
56504 swig_cast_info *equiv;
56505 static int init_run = 0;
56506
56507 if (init_run) return;
56508 init_run = 1;
56509
56510 for (i = 0; i < swig_module.size; i++) {
56511 if (swig_module.types[i]->clientdata) {
56512 equiv = swig_module.types[i]->cast;
56513 while (equiv) {
56514 if (!equiv->converter) {
56515 if (equiv->type && !equiv->type->clientdata)
56516 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56517 }
56518 equiv = equiv->next;
56519 }
56520 }
56521 }
56522 }
56523
56524 #ifdef __cplusplus
56525 #if 0
56526 {
56527 /* c-mode */
56528 #endif
56529 }
56530 #endif
56531
56532
56533
56534 #ifdef __cplusplus
56535 extern "C" {
56536 #endif
56537
56538 /* Python-specific SWIG API */
56539 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56540 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56541 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56542
56543 /* -----------------------------------------------------------------------------
56544 * global variable support code.
56545 * ----------------------------------------------------------------------------- */
56546
56547 typedef struct swig_globalvar {
56548 char *name; /* Name of global variable */
56549 PyObject *(*get_attr)(void); /* Return the current value */
56550 int (*set_attr)(PyObject *); /* Set the value */
56551 struct swig_globalvar *next;
56552 } swig_globalvar;
56553
56554 typedef struct swig_varlinkobject {
56555 PyObject_HEAD
56556 swig_globalvar *vars;
56557 } swig_varlinkobject;
56558
56559 SWIGINTERN PyObject *
56560 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56561 return PyString_FromString("<Swig global variables>");
56562 }
56563
56564 SWIGINTERN PyObject *
56565 swig_varlink_str(swig_varlinkobject *v) {
56566 PyObject *str = PyString_FromString("(");
56567 swig_globalvar *var;
56568 for (var = v->vars; var; var=var->next) {
56569 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56570 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56571 }
56572 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56573 return str;
56574 }
56575
56576 SWIGINTERN int
56577 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56578 PyObject *str = swig_varlink_str(v);
56579 fprintf(fp,"Swig global variables ");
56580 fprintf(fp,"%s\n", PyString_AsString(str));
56581 Py_DECREF(str);
56582 return 0;
56583 }
56584
56585 SWIGINTERN void
56586 swig_varlink_dealloc(swig_varlinkobject *v) {
56587 swig_globalvar *var = v->vars;
56588 while (var) {
56589 swig_globalvar *n = var->next;
56590 free(var->name);
56591 free(var);
56592 var = n;
56593 }
56594 }
56595
56596 SWIGINTERN PyObject *
56597 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56598 PyObject *res = NULL;
56599 swig_globalvar *var = v->vars;
56600 while (var) {
56601 if (strcmp(var->name,n) == 0) {
56602 res = (*var->get_attr)();
56603 break;
56604 }
56605 var = var->next;
56606 }
56607 if (res == NULL && !PyErr_Occurred()) {
56608 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56609 }
56610 return res;
56611 }
56612
56613 SWIGINTERN int
56614 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56615 int res = 1;
56616 swig_globalvar *var = v->vars;
56617 while (var) {
56618 if (strcmp(var->name,n) == 0) {
56619 res = (*var->set_attr)(p);
56620 break;
56621 }
56622 var = var->next;
56623 }
56624 if (res == 1 && !PyErr_Occurred()) {
56625 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56626 }
56627 return res;
56628 }
56629
56630 SWIGINTERN PyTypeObject*
56631 swig_varlink_type(void) {
56632 static char varlink__doc__[] = "Swig var link object";
56633 static PyTypeObject varlink_type;
56634 static int type_init = 0;
56635 if (!type_init) {
56636 const PyTypeObject tmp
56637 = {
56638 PyObject_HEAD_INIT(NULL)
56639 0, /* Number of items in variable part (ob_size) */
56640 (char *)"swigvarlink", /* Type name (tp_name) */
56641 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56642 0, /* Itemsize (tp_itemsize) */
56643 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56644 (printfunc) swig_varlink_print, /* Print (tp_print) */
56645 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56646 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56647 0, /* tp_compare */
56648 (reprfunc) swig_varlink_repr, /* tp_repr */
56649 0, /* tp_as_number */
56650 0, /* tp_as_sequence */
56651 0, /* tp_as_mapping */
56652 0, /* tp_hash */
56653 0, /* tp_call */
56654 (reprfunc)swig_varlink_str, /* tp_str */
56655 0, /* tp_getattro */
56656 0, /* tp_setattro */
56657 0, /* tp_as_buffer */
56658 0, /* tp_flags */
56659 varlink__doc__, /* tp_doc */
56660 0, /* tp_traverse */
56661 0, /* tp_clear */
56662 0, /* tp_richcompare */
56663 0, /* tp_weaklistoffset */
56664 #if PY_VERSION_HEX >= 0x02020000
56665 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56666 #endif
56667 #if PY_VERSION_HEX >= 0x02030000
56668 0, /* tp_del */
56669 #endif
56670 #ifdef COUNT_ALLOCS
56671 0,0,0,0 /* tp_alloc -> tp_next */
56672 #endif
56673 };
56674 varlink_type = tmp;
56675 varlink_type.ob_type = &PyType_Type;
56676 type_init = 1;
56677 }
56678 return &varlink_type;
56679 }
56680
56681 /* Create a variable linking object for use later */
56682 SWIGINTERN PyObject *
56683 SWIG_Python_newvarlink(void) {
56684 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56685 if (result) {
56686 result->vars = 0;
56687 }
56688 return ((PyObject*) result);
56689 }
56690
56691 SWIGINTERN void
56692 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56693 swig_varlinkobject *v = (swig_varlinkobject *) p;
56694 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56695 if (gv) {
56696 size_t size = strlen(name)+1;
56697 gv->name = (char *)malloc(size);
56698 if (gv->name) {
56699 strncpy(gv->name,name,size);
56700 gv->get_attr = get_attr;
56701 gv->set_attr = set_attr;
56702 gv->next = v->vars;
56703 }
56704 }
56705 v->vars = gv;
56706 }
56707
56708 SWIGINTERN PyObject *
56709 SWIG_globals() {
56710 static PyObject *_SWIG_globals = 0;
56711 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56712 return _SWIG_globals;
56713 }
56714
56715 /* -----------------------------------------------------------------------------
56716 * constants/methods manipulation
56717 * ----------------------------------------------------------------------------- */
56718
56719 /* Install Constants */
56720 SWIGINTERN void
56721 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56722 PyObject *obj = 0;
56723 size_t i;
56724 for (i = 0; constants[i].type; ++i) {
56725 switch(constants[i].type) {
56726 case SWIG_PY_POINTER:
56727 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56728 break;
56729 case SWIG_PY_BINARY:
56730 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56731 break;
56732 default:
56733 obj = 0;
56734 break;
56735 }
56736 if (obj) {
56737 PyDict_SetItemString(d, constants[i].name, obj);
56738 Py_DECREF(obj);
56739 }
56740 }
56741 }
56742
56743 /* -----------------------------------------------------------------------------*/
56744 /* Fix SwigMethods to carry the callback ptrs when needed */
56745 /* -----------------------------------------------------------------------------*/
56746
56747 SWIGINTERN void
56748 SWIG_Python_FixMethods(PyMethodDef *methods,
56749 swig_const_info *const_table,
56750 swig_type_info **types,
56751 swig_type_info **types_initial) {
56752 size_t i;
56753 for (i = 0; methods[i].ml_name; ++i) {
56754 const char *c = methods[i].ml_doc;
56755 if (c && (c = strstr(c, "swig_ptr: "))) {
56756 int j;
56757 swig_const_info *ci = 0;
56758 const char *name = c + 10;
56759 for (j = 0; const_table[j].type; ++j) {
56760 if (strncmp(const_table[j].name, name,
56761 strlen(const_table[j].name)) == 0) {
56762 ci = &(const_table[j]);
56763 break;
56764 }
56765 }
56766 if (ci) {
56767 size_t shift = (ci->ptype) - types;
56768 swig_type_info *ty = types_initial[shift];
56769 size_t ldoc = (c - methods[i].ml_doc);
56770 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56771 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56772 if (ndoc) {
56773 char *buff = ndoc;
56774 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56775 if (ptr) {
56776 strncpy(buff, methods[i].ml_doc, ldoc);
56777 buff += ldoc;
56778 strncpy(buff, "swig_ptr: ", 10);
56779 buff += 10;
56780 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56781 methods[i].ml_doc = ndoc;
56782 }
56783 }
56784 }
56785 }
56786 }
56787 }
56788
56789 #ifdef __cplusplus
56790 }
56791 #endif
56792
56793 /* -----------------------------------------------------------------------------*
56794 * Partial Init method
56795 * -----------------------------------------------------------------------------*/
56796
56797 #ifdef __cplusplus
56798 extern "C"
56799 #endif
56800 SWIGEXPORT void SWIG_init(void) {
56801 PyObject *m, *d;
56802
56803 /* Fix SwigMethods to carry the callback ptrs when needed */
56804 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56805
56806 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56807 d = PyModule_GetDict(m);
56808
56809 SWIG_InitializeModule(0);
56810 SWIG_InstallConstants(d,swig_const_table);
56811
56812
56813
56814 #ifndef wxPyUSE_EXPORT
56815 // Make our API structure a CObject so other modules can import it
56816 // from this module.
56817 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56818 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56819 Py_XDECREF(cobj);
56820 #endif
56821
56822 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56823 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56824 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56825 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56826 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56827 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56828 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56829 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56830 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56831 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56832 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56833 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56834 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56835 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56836 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56837 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56838 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56839 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56840 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56841 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56842 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56843 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56844 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56845 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56846 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56847 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56848 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56849 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56850 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56851 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56852 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56853 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56854 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56855 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56856 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56857 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56858 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56859 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56860 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56861 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56862 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56863 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56864 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56865 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56866 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56867 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56868 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56869 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56870 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56871 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56872 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56873 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56874 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56875 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56876 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56877 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56878 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56879 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56880 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56881 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56882 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56883 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56884 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56885 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56886 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56887 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56888 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56889 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56890 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56891 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56892 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56893 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56894 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56895 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56896 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56897 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56898 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56899 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56900 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56901 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56902 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56903 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56904 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56905 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56906 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56907 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56908 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56909 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56910 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56911 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56912 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56913 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56914 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56915 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56916 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56917 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56918 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56919 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56920 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56921 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56922 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56923 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56924 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56925 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56926 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56927 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56928 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56929 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56930 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56931 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56932 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56933 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56934 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56935 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56936 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56937 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56938 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56939 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56940 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56941 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56942 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56943 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56944 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56945 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56946 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56947 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56948 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56949 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56950 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56951 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56952 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56953 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56954 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56955 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56956 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56957 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56958 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56959 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56960 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56961 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56962 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56963 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56964 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56965 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56966 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56967 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56968 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56969 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56970 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56971 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56972 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56973 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56974 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56975 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56976 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56977 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56978 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56979 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56980 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56981 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56982 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56983 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56984 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56985 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56986 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56987 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56988 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56989 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56990 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56991 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56992 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56993 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56994 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56995 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56996 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56997 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56998 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56999 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57000 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57001 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57002 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57003 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57004 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57005 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57006 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57007 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57008 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57009 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57010 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57011 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57012 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57013 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57014 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57015 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57016 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57017 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57018 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57019 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57020 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57021 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57022 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57023 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57024 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57025 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57026 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57027 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57028 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57029 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57030 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57031 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57032 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57033 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57034 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57035 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57036 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57037 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57038 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57039 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57040 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57041 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57042 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57043 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57044 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57045 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57046 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57047 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57048 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57049 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57050 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57051 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57052 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57053 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57054 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57055 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57056 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57057 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57058 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57059 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57060 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57061 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57062 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57063 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57064 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57065 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57066 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57067 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57068 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57069 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57070 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57071 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57072 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57073 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57074 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57075 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57076 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57077 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57078 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57079 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57080 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57081 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57082 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57083 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57084 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57085 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57086 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57087 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57088 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57089 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57090 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57091 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57092 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57093 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57094 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57095 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57096 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57097 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57098 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57099 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57100 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57101 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57102 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57103 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57104 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57105 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57106 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57107 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57108 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57109 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57110 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57111 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57112 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57113 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57114 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57115 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57116 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57117 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57118 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57119 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57120 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57121 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57122 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57123 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57124 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57125 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57126 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57127 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57128 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57129 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57130 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57131 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57132 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57133 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57134 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57135 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57136 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57137 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57138 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57139 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57140 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57141 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57142 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57143 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57144 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57145 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57146 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57147 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57148 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57149 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57150 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57151 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57152 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57153 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57154 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57155 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57156 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57157 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57158 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57159 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57160 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57161 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57162 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57163 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57164 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57165 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57166 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57167 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57168 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57169 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57170 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57171 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57172 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57173 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57174 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57175 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57176 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57177 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57178 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57179 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57180 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57181 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57182 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57183 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57184 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57185 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57186 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57187 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57188 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57189 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57190 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57191 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57192 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57193 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57194 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57195 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57196 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57197 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57198 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57199 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57200 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57201 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57202 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57203 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57204 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57205 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57206 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57207 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57208 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57209 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57210 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57211 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57212 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57213 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57214 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57215 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57216 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57217 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57218 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57219 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57220 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57221 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57222 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57223 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57224 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57225 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57226 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57227 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57228 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57229 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57230 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57231 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57232 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57233 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57234 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57235 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57236 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57237 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57238 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57239 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57240 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57241 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57242 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57243 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57244 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57245 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57246 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57247 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57248 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57249 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57250 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57251 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57252 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57253 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57254 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57255 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57256 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57257 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57258 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57259 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57260 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57261 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57262 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57263 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57264 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57265 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57266 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57267 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57268 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57269 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57270 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57271 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57272 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57273 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57274 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57275 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57276 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57277 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57278 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57279 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57280 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57281 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57282 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57283 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57284 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57285 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57286 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57287 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57288 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57289 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57290 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57291 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57292 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57293 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57294 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57295 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57296 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57297 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57298 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57299 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57300 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57301 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57302 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57303 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57304 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57305 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57306 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57307 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57308 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57309 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57310 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57311 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57312 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57313 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57314 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57315 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57316 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57317 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57318 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57319 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57320 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57321 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57322 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57323 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57324 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57325 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57326 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57327 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57328 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57329 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57330 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57331 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57332 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57333 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57334 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57335 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57336 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57337 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57338 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57339 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57340 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57341 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57342 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57343 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57344 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57345 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57346 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57347 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57348 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57349 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57350 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57351 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57352 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57353 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57354 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57355 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57356 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57357 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57358 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57359 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57360 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57361 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57362 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57363 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57364 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57365 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57366 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57367 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57368 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57369 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57370 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57371 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57372 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57373 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57374 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57375 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57376 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57377 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57378 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57379 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57380 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57381 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57382 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57383 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57384 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57385 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57386 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57387 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57388 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57389 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57390 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57391 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57392 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57393 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57394 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57395 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57396 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57397 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57398 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57399 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57400 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57401 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57402 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57403 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57404 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57405 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57406 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57407 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57408 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57409 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57410 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57411 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57412 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57413 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57414 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57415 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57416 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57417 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57418 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57419 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57420 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57421 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57422 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57423 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57424 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57425 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57426 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57427 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57428 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57429 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57430 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57431 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57432 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57433 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57434 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57435 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57436 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57437 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57438 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57439 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57440 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57441 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57442 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57443 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57444 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57445 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57446 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57447 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57448 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57449 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57450 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57451 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57452 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57453 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57454 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57455 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57456 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57457 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57458 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57459 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57460 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57461 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57462 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57463 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57464 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57465 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57466 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57467 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57468 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57469 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57470 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57471 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57472 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57473 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57474 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57475 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57476 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57477 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57478
57479 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57480
57481
57482 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57483
57484 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57485 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57486 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57487 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57488 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57489 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57490 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57491 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57492 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57493 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57494 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57495 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57496 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57497 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57498 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57499 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57500 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57501 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57502 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57503 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57504 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57505 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57506 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57507 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57508 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57509 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57510 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57511 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57512 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57513 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57514 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57515 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57516 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57517 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57518 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57519 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57520 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57521 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57522 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57523 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57524 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57525 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57526 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57527 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57528 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57529 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57530 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57531 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57532 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57533 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57534 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57535 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57536 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57537 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57538 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57539 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57540 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57541 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57542 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57543 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57544 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57545 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57546 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57547 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57548 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57549 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57550 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57551 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57552 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57553 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57554 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57555 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57556 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57557 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57558 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57559 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57560 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57561 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57562 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57563 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57564 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57565 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57566 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57567 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57568 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57569 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57570 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57571 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57572 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57573 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57574 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57575 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57576 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57577 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57578 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57579 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57580 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57581 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57582 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57583 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57584 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57585 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57586 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57587 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57588 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57589 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57590 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57591 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57592 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57593 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57594 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57595 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57596 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57597 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57598 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57599 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57600 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57601 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57602 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57603 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57604 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57605 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57606 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57607 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57608 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57609 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57610 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57611 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57612 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57613 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57614 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57615 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57616 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57617 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57618 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57619 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57620 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57621 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57622 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57623 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57624 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57625 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57626 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57627 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57628 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57629 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57630 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57631 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57632 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57633 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57634 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57635 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57636 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57637 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57638 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57639 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57640 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57641 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57642 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57643 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57644 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57645 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57646 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57647 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57648 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57649 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57650 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57651 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57652 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57653 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57654 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57655 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57656 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57657 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57658 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57659 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57660 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57661 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57662 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57663 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57664 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57665 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57666 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57667 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57668 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57669 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57670 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57671 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57672 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57673 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57674 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57675 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57676 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57677 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57678 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57679 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57680 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57681 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57682 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57683 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57684 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57685 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57686 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57687 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57688 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57689 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57690 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57691 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57692 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57693 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57694 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57695 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57696
57697 // Initialize threading, some globals and such
57698 __wxPyPreStart(d);
57699
57700
57701 // Although these are defined in __version__ they need to be here too so
57702 // that an assert can be done to ensure that the wxPython and the wxWindows
57703 // versions match.
57704 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57705 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57706 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57707
57708 }
57709
wxWidgets (Impactor)